@intentius/chant-lexicon-fountain 0.45.0 → 0.49.0

package/dist/audit-entities.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Parse-to-graph for `chant audit` (#1567).
+ *
+ * Audit discovery classifies standalone fountain manifests (#1566); this
+ * module turns one classified file's content back into the entity graph the
+ * FTN post-synth checks read (`ctx.entities`), so the same graph-reading
+ * rules that fire on `chant build` fire on an audit of hand-written
+ * `fountain apply` YAML — one implementation per rule, no output-reading
+ * variants to drift.
+ *
+ * Tolerant by contract: the audit runs against any repo, so a malformed
+ * document contributes no entities instead of throwing, and documents are
+ * parsed one at a time so one bad document doesn't take down the file's
+ * others. A name declared twice keeps both declarations in the map (the
+ * second gets a `#n`-suffixed key), so nothing is silently dropped and
+ * FTN017's duplicate-name detection still sees the collision.
+ */
+import type { Declarable } from "@intentius/chant";
+/** Parse standalone fountain YAML (or a fountain-plan.json) into `ctx.entities`. */
+export declare function fountainAuditEntities(content: string): Map<string, Declarable>;
+//# sourceMappingURL=audit-entities.d.ts.map

package/dist/audit-entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-entities.d.ts","sourceRoot":"","sources":["../src/audit-entities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAoB9E"}

package/dist/coverage.d.ts

@@ -65,6 +65,13 @@ export declare function computeFountainCoverage(specJSON: string | Buffer, surfa
 export declare function formatSummary(report: FountainCoverageReport): string;
 export declare function formatVerbose(report: FountainCoverageReport): string;
 /** Run coverage analysis for the fountain lexicon. */
+/**
+ * The offline path behind `coverageReport()` (#1330): the same computation
+ * `coverage.test.ts` runs, over the committed spec snapshot and surface
+ * baseline. Never `fetchSchemas()` — check-lexicon runs on every PR and must
+ * not do network I/O.
+ */
+export declare function coverageReportFromSnapshots(basePath?: string): FountainCoverageReport;
 export declare function analyzeFountainCoverage(opts?: {
     basePath?: string;
     verbose?: boolean;

package/dist/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,uDAAuD;AACvD,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQjD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUxD,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yEAAyE;IACzE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,+EAA+E;IAC/E,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC7D;AAOD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,OAAO,EAAE,eAAe,GACvB,sBAAsB,CAkDxB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAGpE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAkCpE;AAED,sDAAsD;AACtD,wBAAsB,uBAAuB,CAAC,IAAI,CAAC,EAAE;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAsBlC"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,uDAAuD;AACvD,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQjD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUxD,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yEAAyE;IACzE,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yDAAyD;IACzD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,iEAAiE;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,+EAA+E;IAC/E,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC7D;AAOD,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,OAAO,EAAE,eAAe,GACvB,sBAAsB,CAkDxB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAGpE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAkCpE;AAED,sDAAsD;AACtD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,sBAAsB,CASrF;AAED,wBAAsB,uBAAuB,CAAC,IAAI,CAAC,EAAE;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAsBlC"}

package/dist/detect.d.ts

@@ -5,6 +5,11 @@
 export declare function isFountainManifest(doc: unknown): boolean;
 /** The serializer's fountain-plan.json shape: entity name → { kind, spec }. */
 export declare function isFountainPlan(data: unknown): boolean;
+/**
+ * Canonical `detectTemplate` name under `@…/detect` — what edge callers
+ * (and core's detect-bundle guard) import for content detection.
+ */
+export { detectFountainTemplate as detectTemplate };
 /** Template detection for the plugin: raw string input (YAML or JSON). */
 export declare function detectFountainTemplate(data: unknown): boolean;
 //# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAIxD;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CASrD;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAU7D"}
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAIxD;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CASrD;AAED;;;GAGG;AACH,OAAO,EAAE,sBAAsB,IAAI,cAAc,EAAE,CAAC;AAEpD,0EAA0E;AAC1E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAU7D"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "28dd49dfa56314218e8f0679b05ad176cd7996e751444eb51e6887633c04a4ba",
+    "manifest.json": "c4e4aef153956f7e33b8732485af8e2bf16c7e57be9e99574982d2b56c7c461c",
     "meta.json": "6666b7a77db9210a329219c6a5e107e5ae8794a34542f7310ce16d9bf95c64f5",
     "types/index.d.ts": "1dfdcba184fffcf464dac7d1d71ef7abed2ae02a8d638c0de50e0b0317b7eb01",
     "rules/ftn001-no-secret-literals.ts": "897a4ce1ec790b3c1540d32892603bd33ff4bf30eb6ba4cd2565dee356d4962e",
@@ -17,5 +17,5 @@
     "skills/chant-fountain-secrets.md": "27e349a91589510a92e518c7d7824a4a322cab5ef242cf5799373a55cbfcd1cd",
     "skills/chant-fountain-locked-sandboxes.md": "de82f06cb3a08ba6bf3ae45fb9869e21d6da18b9ebe0fc769da8aebaceea7dd1"
   },
-  "composite": "b7579f9b30c25525a5424d24868d39e12858de8ea2da23773c3760edca697810"
+  "composite": "6bd8f5f7bab081c4e3f249f92ac6bfa9a6dd3a94718bba6142046e5e00d8d9f3"
 }

package/dist/lint/audit-catalog.d.ts

@@ -2,13 +2,17 @@
  * The fountain lexicon's chant audit catalog — metadata for the FTN rules,
  * contributed via `fountainPlugin.auditCatalog()` (#687).
  *
- * Every entry carries `yamlBased: false`, which is not an oversight: all of
- * fountain's checks read the chant model (`ctx.entities`), not the emitted
- * manifests (`ctx.outputs`), because the facts they need — which Environment
- * an Agent references, which keys a Vault shadows — live in the typed graph
- * and are flattened by the time YAML exists. So they fire on `chant build`
- * and cannot fire on an audit of standalone fountain YAML. `auditRule()`
- * hardcodes `yamlBased: true`, so these are constructed directly.
+ * All of fountain's checks read the chant model (`ctx.entities`), not the
+ * emitted manifests (`ctx.outputs`), because the facts they need — which
+ * Environment an Agent references, which keys a Vault shadows — live in the
+ * typed graph and are flattened by the time YAML exists. They still fire on
+ * an audit of standalone fountain YAML: the audit parses classified
+ * `fountain.dev/v1` documents back into the entity graph via the plugin's
+ * `auditEntities` (parse-to-graph, #1567), so the post-synth entries are
+ * `yamlBased: true` — one rule implementation serves both paths. The one
+ * exception is FTN001, a declarative lint rule over TypeScript source that
+ * the audit never runs; it stays `yamlBased: false`. `auditRule()` hardcodes
+ * `yamlBased: true`, so these are constructed directly.
  */
 import type { RuleMeta } from "@intentius/chant/audit/catalog";
 export declare const fountainAuditCatalog: Record<string, RuleMeta>;

package/dist/lint/audit-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audit-catalog.d.ts","sourceRoot":"","sources":["../../src/lint/audit-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAwB1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAqEzD,CAAC"}
+{"version":3,"file":"audit-catalog.d.ts","sourceRoot":"","sources":["../../src/lint/audit-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AA6B1E,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAsEzD,CAAC"}

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "fountain",
-  "version": "0.45.0",
+  "version": "0.49.0",
   "chantVersion": ">=0.1.0",
   "namespace": "Fountain",
   "specVersion": "v0.3.0"

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,0BAA0B,CAAC;AAsB7F;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aA8I5B,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,0BAA0B,CAAC;AAuB7F;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aA0J5B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-fountain",
-  "version": "0.45.0",
+  "version": "0.49.0",
   "type": "module",
   "description": "Fountain lexicon for chant — sandboxed agent environments, vaults, and agents as typed estate",
   "license": "Apache-2.0",
@@ -50,7 +50,7 @@
     "bundle": "tsx src/package-cli.ts"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.45.0",
+    "@intentius/chant": "^0.49.0",
     "typescript": "^5.9.3"
   },
   "devDependencies": {

package/src/audit-entities.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+import type { Declarable } from "@intentius/chant";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import { fountainAuditEntities } from "./audit-entities";
+import { fountainSerializer } from "./serializer";
+import { postSynthChecks } from "./lint/post-synth";
+import { propsOf } from "./entity-props";
+
+function ctxOf(entities: Map<string, Declarable>): PostSynthContext {
+  return {
+    outputs: new Map(),
+    entities,
+    buildResult: { outputs: new Map(), entities, warnings: [], errors: [], sourceFileCount: 0 },
+  } as unknown as PostSynthContext;
+}
+
+const runAll = (entities: Map<string, Declarable>) => postSynthChecks.flatMap((c) => c.check(ctxOf(entities)));
+
+const DIRTY = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: dev
+spec:
+  networking_type: unrestricted
+  env_vars:
+    API_URL: https://api.example.com
+    AWS_SECRET_ACCESS_KEY: not-a-real-secret
+---
+apiVersion: fountain.dev/v1
+kind: Vault
+metadata:
+  name: staging
+spec:
+  secrets:
+    - key: API_URL
+      value: https://staging.example.com
+`;
+
+const CLEAN = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: dev
+spec:
+  networking_type: limited
+  networking_config:
+    allowed_hosts:
+      - github.com
+  env_vars:
+    API_URL: https://api.example.com
+---
+apiVersion: fountain.dev/v1
+kind: Agent
+metadata:
+  name: researcher
+spec:
+  model: anthropic/claude-sonnet-4-6
+  runtime: claude
+  environment: dev
+`;
+
+describe("fountainAuditEntities (parse-to-graph, #1567)", () => {
+  it("parses manifests into entities keyed by metadata.name, props under .props", () => {
+    const entities = fountainAuditEntities(DIRTY);
+    expect([...entities.keys()].sort()).toEqual(["dev", "staging"]);
+    const dev = entities.get("dev")!;
+    expect(dev.entityType).toBe("Fountain::V1::Environment");
+    expect(propsOf(dev).networking_type).toBe("unrestricted");
+    expect(propsOf(dev).name).toBe("dev");
+    expect(entities.get("staging")!.entityType).toBe("Fountain::V1::Vault");
+  });
+
+  it("the existing FTN checks fire unchanged over the parsed graph", () => {
+    const diags = runAll(fountainAuditEntities(DIRTY));
+    const ids = diags.map((d) => d.checkId).sort();
+    expect(ids).toContain("FTN011"); // unrestricted networking
+    expect(ids).toContain("FTN012"); // credential-shaped env_vars key
+    expect(ids).toContain("FTN014"); // vault shadows API_URL
+    expect(diags.find((d) => d.checkId === "FTN012")!.severity).toBe("error");
+  });
+
+  it("a clean manifest set yields no findings", () => {
+    expect(runAll(fountainAuditEntities(CLEAN))).toEqual([]);
+  });
+
+  it("a name declared twice keeps both entities (suffixed key), so FTN017 sees the collision", () => {
+    const twice = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: dev
+spec:
+  networking_type: limited
+---
+apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: dev
+spec:
+  networking_type: limited
+`;
+    const entities = fountainAuditEntities(twice);
+    expect([...entities.keys()].sort()).toEqual(["dev", "dev#2"]);
+    expect(runAll(entities).map((d) => d.checkId)).toContain("FTN017");
+  });
+
+  it("a malformed document contributes nothing; the rest of the file still parses", () => {
+    const mixed = `{not yaml [
+---
+apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: dev
+spec:
+  networking_type: limited
+`;
+    const entities = fountainAuditEntities(mixed);
+    expect([...entities.keys()]).toEqual(["dev"]);
+  });
+
+  it("non-fountain documents in the file are skipped, not misread", () => {
+    const entities = fountainAuditEntities("apiVersion: v1\nkind: Pod\nmetadata:\n  name: p\n");
+    expect(entities.size).toBe(0);
+  });
+
+  it("round-trips: serialize -> parse -> same entities (guards the #1286 class)", () => {
+    const entity = (entityType: string, props: Record<string, unknown>): Declarable =>
+      ({ entityType, lexicon: "fountain", props }) as unknown as Declarable;
+    const src = new Map<string, Declarable>([
+      [
+        "dev",
+        entity("Fountain::V1::Environment", {
+          name: "dev",
+          networking_type: "limited",
+          networking_config: { allowed_hosts: ["github.com"] },
+          env_vars: { API_URL: "https://api.example.com" },
+        }),
+      ],
+      [
+        "researcher",
+        entity("Fountain::V1::Agent", {
+          name: "researcher",
+          runtime: "claude",
+          model: "anthropic/claude-sonnet-4-6",
+          environment: "dev",
+        }),
+      ],
+    ]);
+    const parsed = fountainAuditEntities(fountainSerializer.serialize(src) as string);
+    expect([...parsed.keys()].sort()).toEqual(["dev", "researcher"]);
+    for (const [name, before] of src) {
+      const after = parsed.get(name)!;
+      expect(after.entityType).toBe(before.entityType);
+      expect(propsOf(after)).toEqual(propsOf(before));
+    }
+    // and the parsed graph is as quiet as the declared one
+    expect(runAll(parsed)).toEqual([]);
+  });
+});

package/src/audit-entities.ts

@@ -0,0 +1,43 @@
+/**
+ * Parse-to-graph for `chant audit` (#1567).
+ *
+ * Audit discovery classifies standalone fountain manifests (#1566); this
+ * module turns one classified file's content back into the entity graph the
+ * FTN post-synth checks read (`ctx.entities`), so the same graph-reading
+ * rules that fire on `chant build` fire on an audit of hand-written
+ * `fountain apply` YAML — one implementation per rule, no output-reading
+ * variants to drift.
+ *
+ * Tolerant by contract: the audit runs against any repo, so a malformed
+ * document contributes no entities instead of throwing, and documents are
+ * parsed one at a time so one bad document doesn't take down the file's
+ * others. A name declared twice keeps both declarations in the map (the
+ * second gets a `#n`-suffixed key), so nothing is silently dropped and
+ * FTN017's duplicate-name detection still sees the collision.
+ */
+
+import type { Declarable } from "@intentius/chant";
+import { FountainParser } from "./import/parser";
+
+/** Parse standalone fountain YAML (or a fountain-plan.json) into `ctx.entities`. */
+export function fountainAuditEntities(content: string): Map<string, Declarable> {
+  const entities = new Map<string, Declarable>();
+  const parser = new FountainParser();
+  for (const docText of content.split(/^---\s*$/m)) {
+    if (!docText.trim()) continue;
+    let resources;
+    try {
+      resources = parser.parse(docText).resources;
+    } catch {
+      continue; // malformed document — no entities, never a crash
+    }
+    for (const r of resources) {
+      let key = r.logicalId;
+      for (let n = 2; entities.has(key); n++) key = `${r.logicalId}#${n}`;
+      // The plain-object entity shape the checks' `propsOf` reads: authored
+      // props under `.props`, mirroring real createResource instances.
+      entities.set(key, { lexicon: "fountain", entityType: r.type, props: r.properties } as unknown as Declarable);
+    }
+  }
+  return entities;
+}

package/src/codegen/docs.ts

@@ -45,7 +45,7 @@ export const helper = new Agent({
 
 ## The loop
 
-1. \`chant build\` — synthesize and lint. The FTN rules catch open networking, credential literals, and unresolvable \`\${VAR}\` references before review.
+1. \`chant build\` — synthesize and lint. The FTN rules catch open networking, credential literals, and unresolvable \`\${VAR}\` references before review. The same rules run via [\`chant audit\`](/chant/cli/audit/) over a repo of hand-written \`fountain apply\` manifests — no chant project needed; the documents are parsed back into the entity graph.
 2. \`chant run <apply op>\` or call \`fountainApply\` — reconcile against the API. Idempotent by name.
 3. \`chant lifecycle diff --live\` — drift. A UI edit to an owned Environment shows up here.
 4. \`chant import --from\` — adopt UI-built resources into typed files.

package/src/coverage.test.ts

@@ -1,8 +1,15 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { computeFountainCoverage, formatVerbose, EXCLUDED_KINDS, UNSPECIFIED_ENDPOINTS } from "./coverage";
+import {
+  computeFountainCoverage,
+  coverageReportFromSnapshots,
+  formatVerbose,
+  EXCLUDED_KINDS,
+  UNSPECIFIED_ENDPOINTS,
+} from "./coverage";
+import { fountainPlugin } from "./plugin";
 import { fetchSchemas } from "./spec/fetch";
 
 const srcDir = dirname(fileURLToPath(import.meta.url));
@@ -63,6 +70,30 @@ describe("fountain coverage", () => {
   });
 });
 
+// chant #1330 — the same accounting, exposed to check-lexicon through the
+// plugin contract. It must agree with the direct computation above and must
+// stay offline: check-lexicon runs on every PR.
+describe("coverageReport plugin contract", () => {
+  it("reports no unaccounted kinds over the committed snapshots", async () => {
+    const report = await fountainPlugin.coverageReport!();
+    expect(report.unaccountedKinds).toEqual([]);
+    expect(report.unaccountedKinds).toEqual(
+      computeFountainCoverage(spec, surface).unaccountedKinds,
+    );
+  });
+
+  it("does no network I/O", async () => {
+    const spy = vi.spyOn(globalThis, "fetch");
+    try {
+      await fountainPlugin.coverageReport!();
+      coverageReportFromSnapshots();
+      expect(spy).not.toHaveBeenCalled();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});
+
 describe("unspecified upstream endpoints", () => {
   it("records a decision for every endpoint the spec cannot describe", () => {
     // The point of the list is the reasoning, not the route string. An entry

package/src/coverage.ts

@@ -190,6 +190,23 @@ export function formatVerbose(report: FountainCoverageReport): string {
 }
 
 /** Run coverage analysis for the fountain lexicon. */
+/**
+ * The offline path behind `coverageReport()` (#1330): the same computation
+ * `coverage.test.ts` runs, over the committed spec snapshot and surface
+ * baseline. Never `fetchSchemas()` — check-lexicon runs on every PR and must
+ * not do network I/O.
+ */
+export function coverageReportFromSnapshots(basePath?: string): FountainCoverageReport {
+  const base = basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+
+  const spec = readFileSync(join(base, "src", "spec", "fountain-openapi.snapshot.json"), "utf-8");
+  const surface = JSON.parse(
+    readFileSync(join(base, "surface.snapshot.json"), "utf-8"),
+  ) as SurfaceSnapshot;
+
+  return computeFountainCoverage(spec, surface);
+}
+
 export async function analyzeFountainCoverage(opts?: {
   basePath?: string;
   verbose?: boolean;

package/src/detect.ts

@@ -23,6 +23,12 @@ export function isFountainPlan(data: unknown): boolean {
   });
 }
 
+/**
+ * Canonical `detectTemplate` name under `@…/detect` — what edge callers
+ * (and core's detect-bundle guard) import for content detection.
+ */
+export { detectFountainTemplate as detectTemplate };
+
 /** Template detection for the plugin: raw string input (YAML or JSON). */
 export function detectFountainTemplate(data: unknown): boolean {
   if (typeof data === "string") {

package/src/lint/audit-catalog.ts

@@ -2,13 +2,17 @@
  * The fountain lexicon's chant audit catalog — metadata for the FTN rules,
  * contributed via `fountainPlugin.auditCatalog()` (#687).
  *
- * Every entry carries `yamlBased: false`, which is not an oversight: all of
- * fountain's checks read the chant model (`ctx.entities`), not the emitted
- * manifests (`ctx.outputs`), because the facts they need — which Environment
- * an Agent references, which keys a Vault shadows — live in the typed graph
- * and are flattened by the time YAML exists. So they fire on `chant build`
- * and cannot fire on an audit of standalone fountain YAML. `auditRule()`
- * hardcodes `yamlBased: true`, so these are constructed directly.
+ * All of fountain's checks read the chant model (`ctx.entities`), not the
+ * emitted manifests (`ctx.outputs`), because the facts they need — which
+ * Environment an Agent references, which keys a Vault shadows — live in the
+ * typed graph and are flattened by the time YAML exists. They still fire on
+ * an audit of standalone fountain YAML: the audit parses classified
+ * `fountain.dev/v1` documents back into the entity graph via the plugin's
+ * `auditEntities` (parse-to-graph, #1567), so the post-synth entries are
+ * `yamlBased: true` — one rule implementation serves both paths. The one
+ * exception is FTN001, a declarative lint rule over TypeScript source that
+ * the audit never runs; it stays `yamlBased: false`. `auditRule()` hardcodes
+ * `yamlBased: true`, so these are constructed directly.
  */
 
 import type { Authority, RuleMeta } from "@intentius/chant/audit/catalog";
@@ -23,7 +27,11 @@ const OWASP_LLM_INJECTION: Authority = {
   url: "https://owasp.org/www-project-top-10-for-large-language-model-applications/",
 };
 
-/** Entity-based rule: everything fountain ships. */
+/**
+ * Entity-based rule. `yamlBased` defaults to true: the post-synth checks fire
+ * on audited standalone YAML via parse-to-graph (#1567). Pass false only for
+ * a rule the audit genuinely cannot run (FTN001, a source-level lint rule).
+ */
 function rule(
   id: string,
   tier: RuleMeta["tier"],
@@ -31,8 +39,9 @@ function rule(
   title: string,
   remediation: string,
   authority?: Authority[],
+  yamlBased = true,
 ): RuleMeta {
-  return { id, tier, fixKind: "guidance", category, title, remediation, authority, yamlBased: false };
+  return { id, tier, fixKind: "guidance", category, title, remediation, authority, yamlBased };
 }
 
 export const fountainAuditCatalog: Record<string, RuleMeta> = {
@@ -43,6 +52,7 @@ export const fountainAuditCatalog: Record<string, RuleMeta> = {
     "Literal credential in a fountain declaration",
     "Use a ${VAR} substitution reference or an environment secret; never a literal in source.",
     [OWASP_LLM_INJECTION],
+    false, // lint rule over TypeScript source — the audit never runs it
   ),
   FTN010: rule(
     "FTN010",

package/src/plugin.test.ts

@@ -47,11 +47,24 @@ describe("fountain plugin", () => {
     expect(ruleIds.sort()).toEqual(Object.keys(catalog).sort());
   });
 
-  it("marks its checks entity-based so audit does not claim they fire on YAML", () => {
+  it("marks exactly the checks the audit can run as yamlBased (#1567)", () => {
     const catalog = fountainPlugin.auditCatalog?.() ?? {};
-    // Every fountain check reads ctx.entities, so none can fire against
-    // standalone fountain YAML. Flipping one to true would misreport it.
-    expect(Object.values(catalog).every((m) => m.yamlBased === false)).toBe(true);
+    // Every post-synth check fires on standalone fountain YAML via
+    // parse-to-graph (auditEntities), so their entries are yamlBased. FTN001
+    // is a lint rule over TypeScript source the audit never runs — claiming
+    // it fires on YAML would misreport `chant audit --rules`.
+    const postSynthIds = new Set((fountainPlugin.postSynthChecks?.() ?? []).map((c) => c.id));
+    for (const [id, meta] of Object.entries(catalog)) {
+      expect(meta.yamlBased, id).toBe(postSynthIds.has(id));
+    }
+  });
+
+  it("parses standalone manifests into the entity graph via auditEntities (#1567)", () => {
+    const entities = fountainPlugin.auditEntities?.(
+      "apiVersion: fountain.dev/v1\nkind: Environment\nmetadata:\n  name: dev\nspec:\n  networking_type: limited\n",
+    );
+    expect(entities?.size).toBe(1);
+    expect(entities?.get("dev")?.entityType).toBe("Fountain::V1::Environment");
   });
 
   it("scaffolds a closed sandbox by default", () => {

package/src/plugin.ts

@@ -12,6 +12,7 @@ import { fountainSerializer } from "./serializer";
 import { rules } from "./lint/rules";
 import { postSynthChecks } from "./lint/post-synth";
 import { fountainAuditCatalog } from "./lint/audit-catalog";
+import { fountainAuditEntities } from "./audit-entities";
 import { fountainReferenceCatalog } from "./reference-catalog";
 import { detectFountainTemplate } from "./detect";
 import { fountainInitTemplates } from "./init-templates";
@@ -63,6 +64,14 @@ export const fountainPlugin: LexiconPlugin = {
 
   // ── Optional extensions ────────────────────────────────────
 
+  // #1330 — the fact check-lexicon gates on, computed offline from the
+  // committed spec snapshot + surface baseline. Never fetchSchemas():
+  // check-lexicon runs per-PR, no network.
+  async coverageReport(): Promise<{ unaccountedKinds?: string[] }> {
+    const { coverageReportFromSnapshots } = await import("./coverage");
+    return { unaccountedKinds: coverageReportFromSnapshots().unaccountedKinds };
+  },
+
   lintRules() {
     return rules;
   },
@@ -73,6 +82,10 @@ export const fountainPlugin: LexiconPlugin = {
 
   auditCatalog: () => fountainAuditCatalog,
 
+  auditEntities(content: string) {
+    return fountainAuditEntities(content);
+  },
+
   skills: createSkillsLoader(import.meta.url, [
     {
       file: "chant-fountain.md",