@intentius/chant-lexicon-fountain 0.33.0

package/dist/lint/post-synth/ftn012-no-cloud-credential-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn012-no-cloud-credential-env.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn012-no-cloud-credential-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAgB9G,eAAO,MAAM,yBAAyB,EAAE,cAyCvC,CAAC"}

package/dist/lint/post-synth/ftn013-substitution-resolvable.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const substitutionResolvableCheck: PostSynthCheck;
+//# sourceMappingURL=ftn013-substitution-resolvable.d.ts.map

package/dist/lint/post-synth/ftn013-substitution-resolvable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn013-substitution-resolvable.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn013-substitution-resolvable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AA8C9G,eAAO,MAAM,2BAA2B,EAAE,cA8CzC,CAAC"}

package/dist/lint/post-synth/ftn014-vault-shadowing.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const vaultShadowingCheck: PostSynthCheck;
+//# sourceMappingURL=ftn014-vault-shadowing.d.ts.map

package/dist/lint/post-synth/ftn014-vault-shadowing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn014-vault-shadowing.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn014-vault-shadowing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AA0B9G,eAAO,MAAM,mBAAmB,EAAE,cAkCjC,CAAC"}

package/dist/lint/post-synth/ftn015-mcp-secret-env-substitution.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const mcpSecretEnvSubstitutionCheck: PostSynthCheck;
+//# sourceMappingURL=ftn015-mcp-secret-env-substitution.d.ts.map

package/dist/lint/post-synth/ftn015-mcp-secret-env-substitution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn015-mcp-secret-env-substitution.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn015-mcp-secret-env-substitution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAe9G,eAAO,MAAM,6BAA6B,EAAE,cAiC3C,CAAC"}

package/dist/lint/post-synth/ftn016-runtime-model-valid.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const runtimeModelValidCheck: PostSynthCheck;
+//# sourceMappingURL=ftn016-runtime-model-valid.d.ts.map

package/dist/lint/post-synth/ftn016-runtime-model-valid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn016-runtime-model-valid.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn016-runtime-model-valid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAc9G,eAAO,MAAM,sBAAsB,EAAE,cAmCpC,CAAC"}

package/dist/lint/post-synth/ftn017-unique-resource-names.d.ts

@@ -0,0 +1,11 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+/**
+ * FTN017: resource names must be unique per kind.
+ *
+ * fountainApply reconciles by name; two entities of the same kind
+ * resolving to the same fountain name would fight over one live
+ * resource — the second apply step silently becomes an update of the
+ * first one's creation.
+ */
+export declare const uniqueResourceNamesCheck: PostSynthCheck;
+//# sourceMappingURL=ftn017-unique-resource-names.d.ts.map

package/dist/lint/post-synth/ftn017-unique-resource-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn017-unique-resource-names.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/ftn017-unique-resource-names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAG9G;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,cA+BtC,CAAC"}

package/dist/lint/post-synth/index.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const postSynthChecks: PostSynthCheck[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lint/post-synth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAUvE,eAAO,MAAM,eAAe,EAAE,cAAc,EAS3C,CAAC"}

package/dist/lint/rules/ftn001-no-secret-literals.d.ts

@@ -0,0 +1,3 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+export declare const noSecretLiteralsRule: LintRule;
+//# sourceMappingURL=ftn001-no-secret-literals.d.ts.map

package/dist/lint/rules/ftn001-no-secret-literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ftn001-no-secret-literals.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/ftn001-no-secret-literals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,4BAA4B,CAAC;AAyBxF,eAAO,MAAM,oBAAoB,EAAE,QA4ClC,CAAC"}

package/dist/lint/rules/index.d.ts

@@ -0,0 +1,5 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+export { noSecretLiteralsRule } from "./ftn001-no-secret-literals.js";
+/** All lint rules provided by this lexicon (imported by plugin.ts's lintRules()). */
+export declare const rules: LintRule[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lint/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,qFAAqF;AACrF,eAAO,MAAM,KAAK,EAAE,QAAQ,EAA2B,CAAC"}

package/dist/lsp/completions.d.ts

@@ -0,0 +1,7 @@
+import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
+/**
+ * Provide LSP completions for fountain resources — class names after
+ * `new `, property names inside a constructor.
+ */
+export declare function completions(ctx: CompletionContext): CompletionItem[];
+//# sourceMappingURL=completions.d.ts.map

package/dist/lsp/completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../src/lsp/completions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAapF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAEpE"}

package/dist/lsp/hover.d.ts

@@ -0,0 +1,4 @@
+import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
+/** Provide LSP hover information for fountain resources. */
+export declare function hover(ctx: HoverContext): HoverInfo | undefined;
+//# sourceMappingURL=hover.d.ts.map

package/dist/lsp/hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../../src/lsp/hover.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAiE1E,4DAA4D;AAC5D,wBAAgB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,CAE9D"}

package/dist/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "fountain",
+  "version": "0.33.0",
+  "chantVersion": ">=0.1.0",
+  "namespace": "Fountain"
+}

package/dist/meta.json

@@ -0,0 +1,69 @@
+{
+  "Agent": {
+    "resourceType": "Fountain::V1::Agent",
+    "kind": "resource",
+    "lexicon": "fountain",
+    "propertyConstraints": {
+      "environment_id": {
+        "format": "uuid"
+      },
+      "model": {
+        "pattern": "^[a-z0-9_-]+/[a-z0-9._-]+$"
+      },
+      "name": {
+        "minLength": 1,
+        "maxLength": 200
+      },
+      "runtime": {
+        "enum": [
+          "claude",
+          "codex",
+          "gemini",
+          "opencode"
+        ]
+      }
+    }
+  },
+  "Environment": {
+    "resourceType": "Fountain::V1::Environment",
+    "kind": "resource",
+    "lexicon": "fountain",
+    "propertyConstraints": {
+      "name": {
+        "minLength": 1,
+        "maxLength": 200
+      },
+      "networking_type": {
+        "enum": [
+          "unrestricted",
+          "limited"
+        ]
+      }
+    }
+  },
+  "Repository": {
+    "resourceType": "Fountain::V1::Repository",
+    "kind": "property",
+    "lexicon": "fountain",
+    "propertyConstraints": {
+      "mount_path": {
+        "pattern": "^/"
+      },
+      "url": {
+        "pattern": "^https://",
+        "format": "uri"
+      }
+    }
+  },
+  "Vault": {
+    "resourceType": "Fountain::V1::Vault",
+    "kind": "resource",
+    "lexicon": "fountain",
+    "propertyConstraints": {
+      "name": {
+        "minLength": 1,
+        "maxLength": 200
+      }
+    }
+  }
+}

package/dist/op/activities/fountain-apply.d.ts

@@ -0,0 +1,76 @@
+/**
+ * fountain native applier.
+ *
+ * Direct-REST reconciler against fountain's API (the same surface
+ * `fountain apply` uses, but API-first: create-if-new, update-if-changed
+ * by name, optional owned-only prune). Input is the serializer's
+ * `fountain-plan.json` sidecar — entity name → { kind, spec } — so no
+ * YAML parsing happens on the apply side.
+ *
+ * Apply order is Environment → Vault → Agent: agents reference their
+ * environment by entity name in the plan, resolved to the live id here
+ * (mirroring the CLI's name→id resolution in apply.go).
+ *
+ * Secrets: `spec.secrets` entries ({key, value}) are stripped from the
+ * resource body and upserted through the secrets sub-resource. Values are
+ * write-only upstream, so this is upsert-always — a changed value cannot
+ * be detected, only overwritten. (BinaryBourbon/fountain#148's reference
+ * model would make this a plain diff; until then, upsert-always is the
+ * honest semantic.)
+ *
+ * Endpoint/token resolution: explicit args win, then FOUNTAIN_ENDPOINT /
+ * FOUNTAIN_TOKEN, then the hosted default endpoint.
+ */
+export declare const DEFAULT_FOUNTAIN_BASE_URL = "https://founta.inevitable.fyi";
+/** Ownership marker checked by the owned-only prune. */
+export declare const OWNERSHIP_KEY = "managed-by";
+export declare const OWNERSHIP_VALUE = "chant";
+export interface PlanEntry {
+    kind: string;
+    spec: Record<string, unknown>;
+}
+export type FountainPlan = Record<string, PlanEntry>;
+export interface FountainHttp {
+    (method: string, path: string, body?: unknown): Promise<{
+        status: number;
+        json: unknown;
+    }>;
+}
+export interface FountainApplyArgs {
+    /** Path to the serializer's fountain-plan.json. */
+    planPath?: string;
+    /** Inline plan content (takes precedence over planPath). */
+    planContent?: string;
+    endpoint?: string;
+    token?: string;
+    /** Delete chant-owned resources absent from the plan. Off by default. */
+    prune?: boolean;
+}
+export interface FountainApplySummary {
+    created: string[];
+    updated: string[];
+    pruned: string[];
+    secretsUpserted: number;
+}
+export declare function resolveEndpoint(args?: {
+    endpoint?: string;
+}, env?: NodeJS.ProcessEnv): string;
+export declare function resolveToken(args?: {
+    token?: string;
+}, env?: NodeJS.ProcessEnv): string;
+export declare function parsePlan(content: string): FountainPlan;
+/** Split spec.secrets ({key, value}[]) from the resource body. Pure. */
+export declare function splitSecrets(spec: Record<string, unknown>): {
+    body: Record<string, unknown>;
+    secrets: Array<{
+        key: string;
+        value: string;
+    }>;
+};
+/** Is a live resource chant-owned (by its metadata marker)? Pure. */
+export declare function isChantOwned(resource: {
+    metadata?: unknown;
+}): boolean;
+export declare function defaultFountainHttp(endpoint: string, token: string): FountainHttp;
+export declare function fountainApply(args: FountainApplyArgs, http?: FountainHttp): Promise<FountainApplySummary>;
+//# sourceMappingURL=fountain-apply.d.ts.map

package/dist/op/activities/fountain-apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fountain-apply.d.ts","sourceRoot":"","sources":["../../../src/op/activities/fountain-apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,eAAO,MAAM,yBAAyB,kCAAkC,CAAC;AAEzE,wDAAwD;AACxD,eAAO,MAAM,aAAa,eAAe,CAAC;AAC1C,eAAO,MAAM,eAAe,UAAU,CAAC;AAWvC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAErD,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC5F;AAED,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACzB;AAID,wBAAgB,eAAe,CAC7B,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,EAChC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CAGR;AAED,wBAAgB,YAAY,CAC1B,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CAIR;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAEvD;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC3D,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD,CAQA;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAItE;AAID,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAkBjF;AAiBD,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,EACvB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,oBAAoB,CAAC,CA8F/B"}

package/dist/op/activities/fountain-run.d.ts

@@ -0,0 +1,36 @@
+/**
+ * fountainRun — start a conversation from a declared Agent and follow it
+ * to a terminal status.
+ *
+ * Conversations are runs, not declarables (the one fountain kind the
+ * lexicon deliberately does not model as a resource). This op is the
+ * imperative half: resolve the agent by name, POST the conversation,
+ * poll until `completed | failed | timed_out | terminated`, and terminate
+ * on deadline so a hung run never outlives the op that started it.
+ */
+import { type FountainHttp } from "./fountain-apply.js";
+export declare const TERMINAL_STATUSES: Set<string>;
+export interface FountainRunArgs {
+    /** Agent name (resolved against /api/agents) or a raw agent id. */
+    agent: string;
+    prompt?: string;
+    /** Optional vault to attach (subject to the agent's allowlist upstream). */
+    vaultId?: string;
+    endpoint?: string;
+    token?: string;
+    /** Give up (and terminate the conversation) after this long. Default 10 min. */
+    timeoutMs?: number;
+    /** Poll interval. Default 5s. */
+    pollMs?: number;
+    /** Injectable clock/sleep for tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface FountainRunResult {
+    conversationId: string;
+    status: string;
+    /** True when the op hit its deadline and terminated the conversation. */
+    terminatedByDeadline: boolean;
+}
+export declare function resolveAgentId(http: FountainHttp, agent: string): Promise<string>;
+export declare function fountainRun(args: FountainRunArgs, http?: FountainHttp): Promise<FountainRunResult>;
+//# sourceMappingURL=fountain-run.d.ts.map

package/dist/op/activities/fountain-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fountain-run.d.ts","sourceRoot":"","sources":["../../../src/op/activities/fountain-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,iBAAiB,aAA8D,CAAC;AAE7F,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,oBAAoB,EAAE,OAAO,CAAC;CAC/B;AAID,wBAAsB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQvF;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,eAAe,EACrB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAoC5B"}

package/dist/op/activities/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * fountain Op activities — resolved by the core activity registry when a
+ * project's `chant.config.ts` lists the `fountain` lexicon. Contributes
+ * the native applier (`fountainApply` — direct REST against fountain's
+ * API, no CLI, no state file) and the conversation runner (`fountainRun`).
+ */
+export { fountainApply, resolveEndpoint, resolveToken, parsePlan, splitSecrets, isChantOwned, defaultFountainHttp, DEFAULT_FOUNTAIN_BASE_URL, OWNERSHIP_KEY, OWNERSHIP_VALUE, } from "./fountain-apply.js";
+export type { FountainApplyArgs, FountainApplySummary, FountainPlan, PlanEntry, FountainHttp, } from "./fountain-apply.js";
+export { fountainRun, resolveAgentId, TERMINAL_STATUSES } from "./fountain-run.js";
+export type { FountainRunArgs, FountainRunResult } from "./fountain-run.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/op/activities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/op/activities/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,aAAa,EACb,eAAe,EACf,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,aAAa,EACb,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,YAAY,EACZ,SAAS,EACT,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAChF,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/package-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=package-cli.d.ts.map

package/dist/package-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-cli.d.ts","sourceRoot":"","sources":["../src/package-cli.ts"],"names":[],"mappings":""}

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { LexiconPlugin } from "@intentius/chant/lexicon";
+/**
+ * fountain lexicon plugin.
+ *
+ * Implements all required LexiconPlugin lifecycle methods.
+ */
+export declare const fountainPlugin: LexiconPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +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"}

package/dist/reference-catalog.d.ts

@@ -0,0 +1,16 @@
+import type { ReferenceCatalog } from "@intentius/chant/lexicon";
+/**
+ * Fountain reference catalog — how observed fountain resources reference
+ * each other, so `chant graph --live` reconstructs the topology.
+ *
+ * One relationship matters: an Agent runs in an Environment
+ * (`environment_id`). `describeResources` puts `environment_id` in the
+ * agent's observed attributes and indexes environments by `id` (their
+ * physicalId), so the edge resolves with no enrichment pass.
+ *
+ * Vaults are deliberately edge-free here: vault↔agent binding is a
+ * conversation-time choice (scoped by `allowed_vault_ids`), not standing
+ * topology.
+ */
+export declare const fountainReferenceCatalog: ReferenceCatalog;
+//# sourceMappingURL=reference-catalog.d.ts.map

package/dist/reference-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-catalog.d.ts","sourceRoot":"","sources":["../src/reference-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,EAAE,gBAWtC,CAAC"}

package/dist/rules/ftn001-no-secret-literals.ts

@@ -0,0 +1,71 @@
+import ts from "typescript";
+import type { LintRule, LintDiagnostic, LintContext } from "@intentius/chant/lint/rule";
+
+/**
+ * FTN001: no secret literals in fountain resource declarations.
+ *
+ * Environment/Vault secrets and MCP server env values must be substitution
+ * references (`${VAR}`) or provider references — never literal credential
+ * values. A literal in source is a credential in git history.
+ *
+ * Fires on string literals matching well-known credential shapes anywhere
+ * inside a `new Environment/Vault/Agent(...)` expression.
+ */
+
+const FOUNTAIN_KINDS = new Set(["Environment", "Vault", "Agent"]);
+
+const CREDENTIAL_SHAPES: Array<{ pattern: RegExp; label: string }> = [
+  { pattern: /^AKIA[0-9A-Z]{16}$/, label: "AWS access key id" },
+  { pattern: /^(ghp|gho|ghs|ghu)_[A-Za-z0-9]{20,}$/, label: "GitHub token" },
+  { pattern: /^github_pat_[A-Za-z0-9_]{20,}$/, label: "GitHub fine-grained token" },
+  { pattern: /^sk-[A-Za-z0-9_-]{20,}$/, label: "secret API key (sk-)" },
+  { pattern: /^ftn_[A-Za-z0-9]{16,}$/, label: "fountain API key" },
+  { pattern: /^xox[baprs]-[A-Za-z0-9-]{10,}$/, label: "Slack token" },
+  { pattern: /^-----BEGIN [A-Z ]*PRIVATE KEY-----/, label: "private key material" },
+];
+
+export const noSecretLiteralsRule: LintRule = {
+  id: "FTN001",
+  severity: "error",
+  category: "security",
+  description:
+    "No literal credential values in fountain declarations — use ${VAR} substitution or a secret provider",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const diagnostics: LintDiagnostic[] = [];
+    const source = context.sourceFile;
+
+    const visit = (node: ts.Node, insideFountainNew: boolean) => {
+      let inside = insideFountainNew;
+
+      if (ts.isNewExpression(node)) {
+        const name = node.expression.getText(source);
+        const short = name.split(".").pop() ?? name;
+        if (FOUNTAIN_KINDS.has(short)) inside = true;
+      }
+
+      if (inside && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))) {
+        const value = node.text;
+        for (const { pattern, label } of CREDENTIAL_SHAPES) {
+          if (pattern.test(value)) {
+            const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+            diagnostics.push({
+              ruleId: "FTN001",
+              severity: "error",
+              message: `Literal ${label} in a fountain declaration — use \${VAR} substitution or a secret provider`,
+              file: context.filePath,
+              line: line + 1,
+              column: character + 1,
+            });
+            break;
+          }
+        }
+      }
+
+      ts.forEachChild(node, (child) => visit(child, inside));
+    };
+
+    visit(source, false);
+    return diagnostics;
+  },
+};

package/dist/rules/ftn010-networking-explicit.ts

@@ -0,0 +1,37 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN010: Environments must state their networking intent.
+ *
+ * Fountain defaults `networking_type` to `unrestricted` when omitted —
+ * an open-network sandbox by silence. Every declared Environment must set
+ * `networking_type` explicitly so the security posture is a reviewed,
+ * diffable decision.
+ */
+export const networkingExplicitCheck: PostSynthCheck = {
+  id: "FTN010",
+  description: "Environment declarations must set networking_type explicitly",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Environment") continue;
+      const props = propsOf(entity);
+      if (props.networking_type === undefined) {
+        diagnostics.push({
+          checkId: "FTN010",
+          severity: "warning",
+          message:
+            `Environment "${name}" does not set networking_type — fountain defaults to ` +
+            `"unrestricted" (open network). State the intent explicitly.`,
+          entity: name,
+          lexicon: "fountain",
+        });
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/dist/rules/ftn011-no-unrestricted-networking.ts

@@ -0,0 +1,36 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN011: `unrestricted` networking is a warning by default.
+ *
+ * Fountain sandboxes run untrusted agent code; an open-network sandbox is
+ * a real posture some workloads need, but it should read as a deliberate
+ * exception in review. Projects hosting untrusted-agent environments
+ * (concierge-class) should promote this to error via project rules.
+ */
+export const noUnrestrictedNetworkingCheck: PostSynthCheck = {
+  id: "FTN011",
+  description: "Environments should prefer networking_type: limited over unrestricted",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Environment") continue;
+      const props = propsOf(entity);
+      if (props.networking_type === "unrestricted") {
+        diagnostics.push({
+          checkId: "FTN011",
+          severity: "warning",
+          message:
+            `Environment "${name}" uses networking_type: unrestricted — an open-network ` +
+            `sandbox. Prefer "limited" with allowed_hosts; keep unrestricted only as a ` +
+            `reviewed exception.`,
+          entity: name,
+          lexicon: "fountain",
+        });
+      }
+    }
+    return diagnostics;
+  },
+};

package/dist/rules/ftn012-no-cloud-credential-env.ts

@@ -0,0 +1,58 @@
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { propsOf } from "../../entity-props";
+
+/**
+ * FTN012: no cloud-credential-shaped values in Environment env_vars.
+ *
+ * Everything materialized into a sandbox must be presumed exfiltrated the
+ * moment untrusted agent code starts. `env_vars` is plaintext config —
+ * anything credential-shaped belongs in secrets at minimum, and long-lived
+ * cloud credentials should not enter the sandbox at all (see
+ * BinaryBourbon/fountain#148 for the token-only model).
+ */
+
+const CREDENTIAL_KEYS = /^(AWS_SECRET_ACCESS_KEY|AWS_ACCESS_KEY_ID|AWS_SESSION_TOKEN|GOOGLE_APPLICATION_CREDENTIALS|AZURE_CLIENT_SECRET)$/i;
+const CREDENTIAL_VALUES = /^(AKIA[0-9A-Z]{16}|(ghp|gho|ghs|ghu)_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]{10,})$/;
+
+export const noCloudCredentialEnvCheck: PostSynthCheck = {
+  id: "FTN012",
+  description: "Environment env_vars must not carry cloud-credential-shaped keys or values",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [name, entity] of ctx.entities) {
+      if (entity.entityType !== "Fountain::V1::Environment") continue;
+      const envVars = propsOf(entity).env_vars as Record<string, unknown> | undefined;
+      if (!envVars || typeof envVars !== "object") continue;
+
+      for (const [key, value] of Object.entries(envVars)) {
+        if (CREDENTIAL_KEYS.test(key)) {
+          diagnostics.push({
+            checkId: "FTN012",
+            severity: "error",
+            message:
+              `Environment "${name}" env_vars carries cloud-credential key "${key}" — ` +
+              `credentials must not be materialized into the sandbox`,
+            entity: name,
+            lexicon: "fountain",
+          });
+          continue;
+        }
+        if (typeof value === "string" && CREDENTIAL_VALUES.test(value)) {
+          diagnostics.push({
+            checkId: "FTN012",
+            severity: "error",
+            message:
+              `Environment "${name}" env_vars["${key}"] looks like a literal credential — ` +
+              `use secrets or a \${VAR} reference, never a plaintext value`,
+            entity: name,
+            lexicon: "fountain",
+          });
+        }
+      }
+    }
+
+    return diagnostics;
+  },
+};