@intentius/chant-lexicon-fountain 0.33.0 → 0.34.0

package/README.md

@@ -9,8 +9,8 @@ resources: `Environment` (sandbox baseline), `Vault` (env-var overrides),
 start them with the `fountainRun` op.
 
 `chant build` serializes to fountain's own manifest YAML (`fountain apply -f`
-accepts it verbatim) plus a `fountain-plan.json` sidecar that `fountainApply`
-reconciles against the API directly.
+accepts it verbatim) — the same YAML `fountainApply` sends to fountain's bulk
+`POST /api/apply` endpoint in one request.
 
 ```ts
 import { Environment, Agent } from "@intentius/chant-lexicon-fountain";
@@ -52,7 +52,7 @@ added, plus the request schemas deliberately left unmodeled.
 ## Project structure
 
 - `src/plugin.ts` — LexiconPlugin with all lifecycle methods
-- `src/serializer.ts` — manifest YAML + `fountain-plan.json` output
+- `src/serializer.ts` — manifest YAML output
 - `src/codegen/`, `src/spec/` — generation pipeline and spec fetch/parse
 - `src/lint/rules/`, `src/lint/post-synth/` — FTN001 (AST) and FTN010–017
 - `src/op/activities/` — `fountainApply` (reconciler) and `fountainRun`

package/dist/codegen/docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiNH;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAyDjF"}
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkNH;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAyDjF"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "757017e21fc2f8173e8da69305a7f4311ccd8830785f9e86c552e9991a5a804e",
+    "manifest.json": "1f8298cb243abce8502bb115152fd11c88547289737f0c2fa0df7b8129639f53",
     "meta.json": "6666b7a77db9210a329219c6a5e107e5ae8794a34542f7310ce16d9bf95c64f5",
     "types/index.d.ts": "1dfdcba184fffcf464dac7d1d71ef7abed2ae02a8d638c0de50e0b0317b7eb01",
     "rules/ftn001-no-secret-literals.ts": "897a4ce1ec790b3c1540d32892603bd33ff4bf30eb6ba4cd2565dee356d4962e",
@@ -13,9 +13,9 @@
     "rules/ftn015-mcp-secret-env-substitution.ts": "88dc87c8f403a2fe48ee43bc4a4678d95273dba810135c8e74750f1bd62d2564",
     "rules/ftn016-runtime-model-valid.ts": "b4aa86267a411678fe6a8ae3556fd9b34cf1c15aaecfe99790216d529a494f44",
     "rules/ftn017-unique-resource-names.ts": "866f3f385083f96b6e8a18fa6f5624bab43752c5d22e7291e95835e62745d26c",
-    "skills/chant-fountain.md": "71c077dbeb40a95cb3a341d99a54eaefc321e07ba789c8b92574f385f9983f3f",
-    "skills/chant-fountain-secrets.md": "6b968e76ed135adde9e5970495beb752e4d9bcf7b02a2a9501fc18b58676d01e",
+    "skills/chant-fountain.md": "06dd02d19394fa777c7ad91dc54f684d273a36456a8660d41dc9701e48d955b3",
+    "skills/chant-fountain-secrets.md": "27e349a91589510a92e518c7d7824a4a322cab5ef242cf5799373a55cbfcd1cd",
     "skills/chant-fountain-locked-sandboxes.md": "de82f06cb3a08ba6bf3ae45fb9869e21d6da18b9ebe0fc769da8aebaceea7dd1"
   },
-  "composite": "4e29aaf0b03c36a53922b819db6851256b3e5b15f1daa9016d14b96874285ccc"
+  "composite": "3321e342144da2914f44f7085c4bccfc85055c16cf8435288283c28019b4149b"
 }

package/dist/manifest.json

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

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

@@ -1,35 +1,39 @@
 /**
  * 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.
+ * Compiles the serializer's manifest YAML — the same `apiVersion:
+ * fountain.dev/v1` documents `fountain apply -f` accepts — into fountain's
+ * `POST /api/apply` bulk-apply request and sends it in one call. That
+ * endpoint (BinaryBourbon/fountain#151) does the reconciliation server-side:
+ * upsert by name, environments -> vaults -> agents, an agent's
+ * `spec.environment` name resolved against the manifest or the tenant's
+ * existing environments, secrets upserted through the encrypted envelope
+ * path. Best-effort per resource — every result is collected before this
+ * throws, so one bad resource doesn't hide failures in the rest of the
+ * manifest, and a partial apply is never silently reported as clean.
  *
- * 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).
+ * No id resolution happens here anymore: since the server resolves an
+ * agent's `environment` reference by name itself, the manifest's `spec`
+ * passes through unmodified except for one shape adjustment — chant's
+ * authored `secrets` is an ordered `{key, value}[]`, the wire format wants
+ * `{KEY: value}` (see `toApplyPayload`).
  *
- * 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.)
+ * Prune (opt-in, chant-owned only) isn't part of bulk apply, so it still
+ * lists each kind's live state and deletes what's absent from the
+ * manifest, same as before.
  *
  * 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";
+export declare const DEFAULT_FOUNTAIN_BASE_URL = "https://fountain.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 {
+export interface ManifestResource {
     kind: string;
+    name: string;
     spec: Record<string, unknown>;
 }
-export type FountainPlan = Record<string, PlanEntry>;
 export interface FountainHttp {
     (method: string, path: string, body?: unknown): Promise<{
         status: number;
@@ -37,13 +41,13 @@ export interface FountainHttp {
     }>;
 }
 export interface FountainApplyArgs {
-    /** Path to the serializer's fountain-plan.json. */
-    planPath?: string;
-    /** Inline plan content (takes precedence over planPath). */
-    planContent?: string;
+    /** Path to the serializer's compiled fountain manifest YAML. */
+    manifestPath?: string;
+    /** Inline manifest YAML content (takes precedence over manifestPath). */
+    manifestContent?: string;
     endpoint?: string;
     token?: string;
-    /** Delete chant-owned resources absent from the plan. Off by default. */
+    /** Delete chant-owned resources absent from the manifest. Off by default. */
     prune?: boolean;
 }
 export interface FountainApplySummary {
@@ -58,15 +62,14 @@ export declare function resolveEndpoint(args?: {
 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;
-    }>;
-};
+/** Parse the serializer's multi-document manifest YAML into apply resources. Pure. */
+export declare function parseManifest(content: string): ManifestResource[];
+/**
+ * Fountain's bulk-apply spec takes `secrets` as a `{KEY: value}` map;
+ * chant's authored shape is an ordered `{key, value}[]`. Convert only that
+ * one field — the rest of spec passes through untouched. Pure.
+ */
+export declare function toApplyPayload(spec: Record<string, unknown>): Record<string, unknown>;
 /** Is a live resource chant-owned (by its metadata marker)? Pure. */
 export declare function isChantOwned(resource: {
     metadata?: unknown;

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

@@ -1 +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"}
+{"version":3,"file":"fountain-apply.d.ts","sourceRoot":"","sources":["../../../src/op/activities/fountain-apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,eAAO,MAAM,yBAAyB,oCAAoC,CAAC;AAE3E,wDAAwD;AACxD,eAAO,MAAM,aAAa,eAAe,CAAC;AAC1C,eAAO,MAAM,eAAe,UAAU,CAAC;AAavC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,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,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,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;AAMD,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAajE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUrF;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;AA+BD,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,EACvB,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,oBAAoB,CAAC,CAyD/B"}

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

@@ -4,8 +4,8 @@
  * 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 { fountainApply, resolveEndpoint, resolveToken, parseManifest, toApplyPayload, isChantOwned, defaultFountainHttp, DEFAULT_FOUNTAIN_BASE_URL, OWNERSHIP_KEY, OWNERSHIP_VALUE, } from "./fountain-apply.js";
+export type { FountainApplyArgs, FountainApplySummary, ManifestResource, 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

@@ -1 +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"}
+{"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,aAAa,EACb,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,yBAAyB,EACzB,aAAa,EACb,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,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/serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgC,MAAM,kBAAkB,CAAC;AAsBjF,eAAO,MAAM,kBAAkB,EAAE,UAwDhC,CAAC"}
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,kBAAkB,CAAC;AA2B/D,eAAO,MAAM,kBAAkB,EAAE,UAgDhC,CAAC"}

package/dist/skills/chant-fountain-secrets.md

@@ -11,7 +11,7 @@ user-invocable: true
 Everything materialized into a fountain sandbox must be presumed exfiltrated once untrusted agent code runs. Order of preference:
 
 1. **`${VAR}` substitution references** in agent config (MCP server env, system prompts). Resolved at spawn from the merged environment + vault sets. Never a value in source.
-2. **Environment secrets** (`spec.secrets`) — encrypted at rest, write-only over the API (values are never returned once stored). `fountainApply` upserts them through the sub-resource; a changed value cannot be detected, only overwritten.
+2. **Environment secrets** (`spec.secrets`) — encrypted at rest, write-only over the API (values are never returned once stored). `fountainApply` sends them inline with the rest of the resource in the bulk apply request, and the server upserts them through the encrypted envelope path; a changed value cannot be detected, only overwritten.
 3. **`env_vars`** — plaintext config only. FTN012 errors on credential-shaped keys or values here.
 
 Never put a literal credential anywhere in a declaration: FTN001 catches known shapes (AWS keys, GitHub/Slack tokens, `sk-`/`ftn_` keys, private key material) at the AST; FTN015 errors on secret-shaped MCP env keys that are not `${VAR}` references.

package/dist/skills/chant-fountain.md

@@ -10,7 +10,7 @@ user-invocable: true
 
 [fountain](https://github.com/BinaryBourbon/fountain) runs coding agents in sandboxed VMs. Its workload layer is three kinds — `Environment` (sandbox baseline), `Vault` (env-var overrides), `Agent` (a runnable agent config) — and this lexicon declares them as typed chant resources. Conversations are runs, not resources: start them with the `fountainRun` op, never declare them.
 
-The source of truth is the TypeScript in `src/`. `chant build` serializes it to fountain's own manifest YAML (ejectable — `fountain apply -f` accepts it verbatim) plus a `fountain-plan.json` sidecar that `fountainApply` reconciles against the API directly: create-if-new, update-by-name, opt-in owned-only prune keyed on the `managed-by: chant` metadata marker.
+The source of truth is the TypeScript in `src/`. `chant build` serializes it to fountain's own manifest YAML (ejectable — `fountain apply -f` accepts it verbatim). `fountainApply` sends that same YAML to fountain's bulk `POST /api/apply` endpoint in one request: create-if-new, update-by-name, opt-in owned-only prune keyed on the `managed-by: chant` metadata marker.
 
 ## Authoring
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-fountain",
-  "version": "0.33.0",
+  "version": "0.34.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.33.0",
+    "@intentius/chant": "^0.34.0",
     "typescript": "^5.9.3"
   },
   "devDependencies": {

package/src/codegen/docs.ts

@@ -55,7 +55,7 @@ export const helper = new Agent({
 
 \`FOUNTAIN_ENDPOINT\` (defaults to the hosted instance) and \`FOUNTAIN_TOKEN\`. Mint a token via \`POST /api/auth/token\` with email and password, or from the account UI. The same code applies to a local \`mix phx.server\` fountain by pointing \`FOUNTAIN_ENDPOINT\` at it — registration and token mint work headless, so CI needs no browser.`;
 
-const outputFormat = `The fountain lexicon serializes to fountain's own manifest YAML plus a \`fountain-plan.json\` sidecar.
+const outputFormat = `The fountain lexicon serializes to fountain's own manifest YAML — nothing else. \`fountainApply\` reads that same YAML, so there is no sidecar to keep in sync with it.
 
 ## Manifests
 
@@ -75,17 +75,17 @@ spec:
 
 The output is ejectable — \`fountain apply -f\` accepts it verbatim, so adopting chant here does not trap the manifests behind chant.
 
-## The plan sidecar
+## Applying the manifest
 
-\`fountain-plan.json\` is entity name → \`{ kind, spec }\`. The \`fountainApply\` activity reconciles from it directly against the REST API, so nothing on the apply side parses YAML. Apply order is Environment → Vault → Agent; an agent's \`environment\` reference carries the entity name and is resolved to the live id at apply.
+\`fountainApply\` parses this same YAML and sends it to fountain's bulk \`POST /api/apply\` endpoint in one request — the server reconciles by name, Environment → Vault → Agent, and resolves an agent's \`environment\` reference itself, against the manifest or the tenant's existing environments. See the Ops page for the activity's own behavior (prune, secrets, failure reporting).
 
 ## Ownership
 
-Resources carrying \`metadata."managed-by": chant\` are chant-owned. That marker gates the opt-in prune (\`fountainApply\` deletes only owned resources absent from the plan) and the \`--owned\` filter on drift and live export. Set it on every declaration you want reconciled.
+Resources carrying \`metadata."managed-by": chant\` are chant-owned. That marker gates the opt-in prune (\`fountainApply\` deletes only owned resources absent from the manifest) and the \`--owned\` filter on drift and live export. Set it on every declaration you want reconciled.
 
 ## Secrets
 
-\`spec.secrets\` entries are split out of 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.`;
+\`spec.secrets\` is authored as an ordered \`{key, value}[]\`, same as any other typed prop. \`fountainApply\` converts it to the \`{KEY: value}\` map fountain's bulk apply expects on the wire; the server upserts it through the encrypted envelope path. Values are write-only upstream, so this is upsert-always — a changed value cannot be detected, only overwritten.`;
 
 const resourcesPage = `The lexicon types the three kinds \`fountain apply\` reconciles — the workload
 layer of [fountain](https://github.com/BinaryBourbon/fountain). Types are
@@ -166,17 +166,18 @@ const opsPage = `Two op activities ship with the lexicon, resolvable by name via
 
 ## fountainApply
 
-The native applier: a direct-REST reconciler over the serializer's \`fountain-plan.json\`.
+The native applier: compiles the serializer's manifest YAML into fountain's bulk \`POST /api/apply\` request and sends it in one call.
 
 | Behavior | Detail |
 |---|---|
-| Create / update | By name. A resource in the plan that exists live is updated; one that does not is created. |
-| Order | Environment → Vault → Agent, so an agent's environment reference resolves to a live id. |
-| Prune | Off by default. With \`prune: true\`, chant-owned resources absent from the plan are deleted, in reverse order. |
-| Secrets | Split from the body and upserted through the secrets sub-resource. Upsert-always — values are write-only upstream. |
+| Create / update | By name, reconciled server-side. An agent's \`environment\` reference resolves by name — against the manifest or the tenant's existing environments — without a client-side id lookup. |
+| Order | Environment → Vault → Agent, fixed server-side regardless of manifest order. |
+| Prune | Off by default. With \`prune: true\`, chant-owned resources absent from the manifest are deleted, in reverse order — the one thing bulk apply doesn't cover, so this still lists live state per kind. |
+| Secrets | \`spec.secrets\` converts from chant's authored \`{key, value}[]\` to the wire's \`{KEY: value}\` map; the server upserts them through the encrypted envelope path in the same request. Upsert-always — values are write-only upstream. |
+| Failure | Best-effort per resource. Every result is collected before this throws, so one bad resource doesn't hide failures elsewhere in the manifest. |
 
 \`\`\`typescript
-await fountainApply({ planPath: "build/fountain-plan.json", prune: true });
+await fountainApply({ manifestPath: "build/fountain.yaml", prune: true });
 \`\`\`
 
 Endpoint and token resolution: explicit args win, then \`FOUNTAIN_ENDPOINT\` / \`FOUNTAIN_TOKEN\`, then the hosted default.

package/src/op/activities/fountain-apply.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, it } from "vitest";
 import {
   fountainApply,
-  splitSecrets,
+  parseManifest,
+  toApplyPayload,
   isChantOwned,
   resolveEndpoint,
-  parsePlan,
   type FountainHttp,
-  type FountainPlan,
 } from "./fountain-apply";
 import { fountainRun } from "./fountain-run";
 
@@ -32,26 +31,65 @@ function fakeHttp(routes: Record<string, { status: number; json?: unknown }>): {
   return { http, calls };
 }
 
-const EMPTY_LISTS = {
-  "GET /api/environments": { status: 200, json: { data: [] } },
-  "GET /api/vaults": { status: 200, json: { data: [] } },
-  "GET /api/agents": { status: 200, json: { data: [] } },
-};
+const MANIFEST = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: concierge-env
+spec:
+  networking_type: limited
+---
+apiVersion: fountain.dev/v1
+kind: Agent
+metadata:
+  name: researcher
+spec:
+  model: a/m
+  runtime: claude
+  environment: concierge-env
+`;
 
 describe("pure helpers", () => {
   it("resolveEndpoint precedence: arg > env > default", () => {
     expect(resolveEndpoint({ endpoint: "http://x/" }, {})).toBe("http://x");
     expect(resolveEndpoint({}, { FOUNTAIN_ENDPOINT: "http://env" })).toBe("http://env");
-    expect(resolveEndpoint({}, {})).toBe("https://founta.inevitable.fyi");
+    expect(resolveEndpoint({}, {})).toBe("https://fountain.inevitable.fyi");
   });
 
-  it("splitSecrets extracts valid entries and leaves the body clean", () => {
-    const { body, secrets } = splitSecrets({
+  it("parseManifest reads kind/name/spec from each YAML document", () => {
+    const resources = parseManifest(MANIFEST);
+    expect(resources).toEqual([
+      { kind: "Environment", name: "concierge-env", spec: { networking_type: "limited" } },
+      {
+        kind: "Agent",
+        name: "researcher",
+        spec: { model: "a/m", runtime: "claude", environment: "concierge-env" },
+      },
+    ]);
+  });
+
+  it("parseManifest skips documents with an unknown or missing kind", () => {
+    const resources = parseManifest(
+      "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: n\nspec: {}\n",
+    );
+    expect(resources).toEqual([]);
+  });
+
+  it("parseManifest ignores blank documents", () => {
+    expect(parseManifest("")).toEqual([]);
+    expect(parseManifest("\n---\n\n")).toEqual([]);
+  });
+
+  it("toApplyPayload converts the authored secrets array into a key/value map", () => {
+    const payload = toApplyPayload({
       name: "e",
       secrets: [{ key: "K", value: "v" }, { bogus: true }],
     });
-    expect(body).toEqual({ name: "e" });
-    expect(secrets).toEqual([{ key: "K", value: "v" }]);
+    expect(payload).toEqual({ name: "e", secrets: { K: "v" } });
+  });
+
+  it("toApplyPayload passes spec through unchanged when there is no secrets array", () => {
+    const spec = { name: "e", networking_type: "limited" };
+    expect(toApplyPayload(spec)).toEqual(spec);
   });
 
   it("isChantOwned keys on the metadata marker", () => {
@@ -62,67 +100,170 @@ describe("pure helpers", () => {
 });
 
 describe("fountainApply", () => {
-  it("creates in Environment -> Vault -> Agent order and resolves the environment ref", async () => {
-    const plan: FountainPlan = {
-      researcher: {
-        kind: "Agent",
-        spec: { name: "researcher", model: "a/m", runtime: "claude", environment: "conciergeEnv" },
-      },
-      conciergeEnv: { kind: "Environment", spec: { name: "concierge-env", networking_type: "limited" } },
-    };
-
+  it("sends the whole manifest in one POST /api/apply call", async () => {
     const { http, calls } = fakeHttp({
-      ...EMPTY_LISTS,
-      "POST /api/environments": { status: 201, json: { data: { id: "env-1" } } },
-      "POST /api/agents": { status: 201, json: { data: { id: "agent-1" } } },
+      "POST /api/apply": {
+        status: 200,
+        json: {
+          data: {
+            results: [
+              { kind: "Environment", name: "concierge-env", action: "created", errors: null, secrets: [] },
+              { kind: "Agent", name: "researcher", action: "created", errors: null, secrets: [] },
+            ],
+          },
+        },
+      },
     });
 
-    const summary = await fountainApply({ planContent: JSON.stringify(plan) }, http);
+    const summary = await fountainApply({ manifestContent: MANIFEST }, http);
 
-    const mutations = calls.filter((c) => c.method === "POST");
-    expect(mutations.map((c) => c.path)).toEqual(["/api/environments", "/api/agents"]);
-    const agentBody = mutations[1].body as Record<string, unknown>;
-    expect(agentBody.environment_id).toBe("env-1");
-    expect(agentBody.environment).toBeUndefined();
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toMatchObject({ method: "POST", path: "/api/apply" });
+    const body = calls[0].body as { resources: Array<{ kind: string; name: string; spec: unknown }> };
+    expect(body.resources).toEqual([
+      { kind: "Environment", name: "concierge-env", spec: { networking_type: "limited" } },
+      { kind: "Agent", name: "researcher", spec: { model: "a/m", runtime: "claude", environment: "concierge-env" } },
+    ]);
     expect(summary.created).toEqual(["Environment/concierge-env", "Agent/researcher"]);
   });
 
-  it("updates by name when the resource already exists", async () => {
-    const plan: FountainPlan = {
-      v: { kind: "Vault", spec: { name: "staging-creds", description: "d" } },
-    };
+  it("does not resolve the agent's environment reference client-side — the server does that now", async () => {
     const { http, calls } = fakeHttp({
-      ...EMPTY_LISTS,
-      "GET /api/vaults": { status: 200, json: { data: [{ id: "v-9", name: "staging-creds" }] } },
-      "PUT /api/vaults/v-9": { status: 200, json: { data: { id: "v-9" } } },
+      "POST /api/apply": {
+        status: 200,
+        json: { data: { results: [{ kind: "Agent", name: "researcher", action: "created", errors: null, secrets: [] }] } },
+      },
     });
 
-    const summary = await fountainApply({ planContent: JSON.stringify(plan) }, http);
-    expect(summary.updated).toEqual(["Vault/staging-creds"]);
-    expect(calls.some((c) => c.method === "PUT" && c.path === "/api/vaults/v-9")).toBe(true);
+    await fountainApply({ manifestContent: MANIFEST }, http);
+    const body = calls[0].body as { resources: Array<{ spec: Record<string, unknown> }> };
+    expect(body.resources[1].spec.environment).toBe("concierge-env");
+    expect(body.resources[1].spec.environment_id).toBeUndefined();
   });
 
-  it("upserts secrets through the sub-resource", async () => {
-    const plan: FountainPlan = {
-      e: {
-        kind: "Environment",
-        spec: { name: "e", secrets: [{ key: "OPENAI_API_KEY", value: "${FROM_PROVIDER}" }] },
-      },
-    };
+  it("reports updated actions and converts spec.secrets to a map on the wire", async () => {
+    const manifest = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: e
+spec:
+  secrets:
+    - key: OPENAI_API_KEY
+      value: sk-abc
+`;
     const { http, calls } = fakeHttp({
-      ...EMPTY_LISTS,
-      "POST /api/environments": { status: 201, json: { data: { id: "env-1" } } },
-      "POST /api/environments/env-1/secrets": { status: 201 },
+      "POST /api/apply": {
+        status: 200,
+        json: {
+          data: {
+            results: [
+              {
+                kind: "Environment",
+                name: "e",
+                action: "updated",
+                errors: null,
+                secrets: [{ key: "OPENAI_API_KEY", action: "upserted", errors: null }],
+              },
+            ],
+          },
+        },
+      },
     });
 
-    const summary = await fountainApply({ planContent: JSON.stringify(plan) }, http);
+    const summary = await fountainApply({ manifestContent: manifest }, http);
+    expect(summary.updated).toEqual(["Environment/e"]);
     expect(summary.secretsUpserted).toBe(1);
-    const create = calls.find((c) => c.method === "POST" && c.path === "/api/environments")!;
-    expect((create.body as Record<string, unknown>).secrets).toBeUndefined();
+    const body = calls[0].body as { resources: Array<{ spec: Record<string, unknown> }> };
+    expect(body.resources[0].spec.secrets).toEqual({ OPENAI_API_KEY: "sk-abc" });
+  });
+
+  it("throws with every failure once all results are in, not just the first", async () => {
+    const manifest = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: bad-env
+spec: {}
+---
+apiVersion: fountain.dev/v1
+kind: Vault
+metadata:
+  name: bad-vault
+spec: {}
+`;
+    const { http } = fakeHttp({
+      "POST /api/apply": {
+        status: 200,
+        json: {
+          data: {
+            results: [
+              {
+                kind: "Environment",
+                name: "bad-env",
+                action: "error",
+                errors: { name: ["has already been taken"] },
+                secrets: [],
+              },
+              {
+                kind: "Vault",
+                name: "bad-vault",
+                action: "error",
+                errors: { name: ["has already been taken"] },
+                secrets: [],
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    await expect(fountainApply({ manifestContent: manifest }, http)).rejects.toThrow(/2 failure/);
+  });
+
+  it("throws on a failed secret upsert", async () => {
+    const manifest = `apiVersion: fountain.dev/v1
+kind: Vault
+metadata:
+  name: v
+spec:
+  secrets:
+    - key: BAD
+      value: x
+`;
+    const { http } = fakeHttp({
+      "POST /api/apply": {
+        status: 200,
+        json: {
+          data: {
+            results: [
+              {
+                kind: "Vault",
+                name: "v",
+                action: "created",
+                errors: null,
+                secrets: [{ key: "BAD", action: "error", errors: { value: ["must be a string"] } }],
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    await expect(fountainApply({ manifestContent: manifest }, http)).rejects.toThrow(/BAD/);
+  });
+
+  it("throws when the server rejects the request outright", async () => {
+    const { http } = fakeHttp({ "POST /api/apply": { status: 500 } });
+    await expect(fountainApply({ manifestContent: MANIFEST }, http)).rejects.toThrow(/500/);
+  });
+
+  it("skips the POST entirely for an empty manifest", async () => {
+    const { http, calls } = fakeHttp({});
+    const summary = await fountainApply({ manifestContent: "" }, http);
+    expect(calls).toHaveLength(0);
+    expect(summary).toEqual({ created: [], updated: [], pruned: [], secretsUpserted: 0 });
   });
 
   it("prunes only chant-owned resources, in reverse kind order", async () => {
-    const plan: FountainPlan = {};
     const { http, calls } = fakeHttp({
       "GET /api/environments": {
         status: 200,
@@ -142,15 +283,35 @@ describe("fountainApply", () => {
       "DELETE /api/environments/e-1": { status: 204 },
     });
 
-    const summary = await fountainApply({ planContent: "{}", prune: true }, http);
+    const summary = await fountainApply({ manifestContent: "", prune: true }, http);
     const deletes = calls.filter((c) => c.method === "DELETE").map((c) => c.path);
     expect(deletes).toEqual(["/api/agents/a-1", "/api/environments/e-1"]);
     expect(summary.pruned).toEqual(["Agent/owned-agent", "Environment/owned-env"]);
   });
 
-  it("parsePlan round-trips", () => {
-    const plan = parsePlan('{"e":{"kind":"Environment","spec":{"name":"e"}}}');
-    expect(plan.e.kind).toBe("Environment");
+  it("does not prune a resource still present in the manifest", async () => {
+    const manifest = `apiVersion: fountain.dev/v1
+kind: Environment
+metadata:
+  name: kept-env
+spec: {}
+`;
+    const { http, calls } = fakeHttp({
+      "POST /api/apply": {
+        status: 200,
+        json: { data: { results: [{ kind: "Environment", name: "kept-env", action: "updated", errors: null, secrets: [] }] } },
+      },
+      "GET /api/environments": {
+        status: 200,
+        json: { data: [{ id: "e-1", name: "kept-env", metadata: { "managed-by": "chant" } }] },
+      },
+      "GET /api/vaults": { status: 200, json: { data: [] } },
+      "GET /api/agents": { status: 200, json: { data: [] } },
+    });
+
+    const summary = await fountainApply({ manifestContent: manifest, prune: true }, http);
+    expect(calls.some((c) => c.method === "DELETE")).toBe(false);
+    expect(summary.pruned).toEqual([]);
   });
 });
 

package/src/op/activities/fountain-apply.ts

@@ -1,30 +1,35 @@
 /**
  * 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.
+ * Compiles the serializer's manifest YAML — the same `apiVersion:
+ * fountain.dev/v1` documents `fountain apply -f` accepts — into fountain's
+ * `POST /api/apply` bulk-apply request and sends it in one call. That
+ * endpoint (BinaryBourbon/fountain#151) does the reconciliation server-side:
+ * upsert by name, environments -> vaults -> agents, an agent's
+ * `spec.environment` name resolved against the manifest or the tenant's
+ * existing environments, secrets upserted through the encrypted envelope
+ * path. Best-effort per resource — every result is collected before this
+ * throws, so one bad resource doesn't hide failures in the rest of the
+ * manifest, and a partial apply is never silently reported as clean.
  *
- * 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).
+ * No id resolution happens here anymore: since the server resolves an
+ * agent's `environment` reference by name itself, the manifest's `spec`
+ * passes through unmodified except for one shape adjustment — chant's
+ * authored `secrets` is an ordered `{key, value}[]`, the wire format wants
+ * `{KEY: value}` (see `toApplyPayload`).
  *
- * 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.)
+ * Prune (opt-in, chant-owned only) isn't part of bulk apply, so it still
+ * lists each kind's live state and deletes what's absent from the
+ * manifest, same as before.
  *
  * Endpoint/token resolution: explicit args win, then FOUNTAIN_ENDPOINT /
  * FOUNTAIN_TOKEN, then the hosted default endpoint.
  */
 
 import { readFileSync } from "node:fs";
+import { parseYAML } from "@intentius/chant/yaml";
 
-export const DEFAULT_FOUNTAIN_BASE_URL = "https://founta.inevitable.fyi";
+export const DEFAULT_FOUNTAIN_BASE_URL = "https://fountain.inevitable.fyi";
 
 /** Ownership marker checked by the owned-only prune. */
 export const OWNERSHIP_KEY = "managed-by";
@@ -36,28 +41,29 @@ const KIND_PATHS: Record<string, string> = {
   Agent: "agents",
 };
 
-/** Environments before vaults before agents; prune runs in reverse. */
+const KINDS = new Set(Object.keys(KIND_PATHS));
+
+/** Prune-only ordering now — bulk apply reconciles create/update order itself. */
 const APPLY_ORDER = ["Environment", "Vault", "Agent"] as const;
 
-export interface PlanEntry {
+export interface ManifestResource {
   kind: string;
+  name: 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;
+  /** Path to the serializer's compiled fountain manifest YAML. */
+  manifestPath?: string;
+  /** Inline manifest YAML content (takes precedence over manifestPath). */
+  manifestContent?: string;
   endpoint?: string;
   token?: string;
-  /** Delete chant-owned resources absent from the plan. Off by default. */
+  /** Delete chant-owned resources absent from the manifest. Off by default. */
   prune?: boolean;
 }
 
@@ -87,22 +93,41 @@ export function resolveToken(
   return token;
 }
 
-export function parsePlan(content: string): FountainPlan {
-  return JSON.parse(content) as FountainPlan;
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/** Parse the serializer's multi-document manifest YAML into apply resources. Pure. */
+export function parseManifest(content: string): ManifestResource[] {
+  const resources: ManifestResource[] = [];
+  for (const docText of content.split(/^---\s*$/m)) {
+    if (!docText.trim()) continue;
+    const doc = parseYAML(docText);
+    const kind = typeof doc.kind === "string" ? doc.kind : "";
+    if (!KINDS.has(kind)) continue;
+    const meta = isRecord(doc.metadata) ? doc.metadata : {};
+    const name = typeof meta.name === "string" ? meta.name : "";
+    const spec = isRecord(doc.spec) ? doc.spec : {};
+    resources.push({ kind, name, spec });
+  }
+  return resources;
 }
 
-/** Split spec.secrets ({key, value}[]) from the resource body. Pure. */
-export function splitSecrets(spec: Record<string, unknown>): {
-  body: Record<string, unknown>;
-  secrets: Array<{ key: string; value: string }>;
-} {
-  const { secrets, ...body } = spec;
-  if (!Array.isArray(secrets)) return { body: spec, secrets: [] };
-  const valid = secrets.filter(
-    (s): s is { key: string; value: string } =>
-      !!s && typeof s === "object" && typeof (s as { key?: unknown }).key === "string",
-  );
-  return { body, secrets: valid };
+/**
+ * Fountain's bulk-apply spec takes `secrets` as a `{KEY: value}` map;
+ * chant's authored shape is an ordered `{key, value}[]`. Convert only that
+ * one field — the rest of spec passes through untouched. Pure.
+ */
+export function toApplyPayload(spec: Record<string, unknown>): Record<string, unknown> {
+  const { secrets, ...rest } = spec;
+  if (!Array.isArray(secrets)) return spec;
+  const map: Record<string, string> = {};
+  for (const entry of secrets) {
+    if (entry && typeof entry === "object" && typeof (entry as { key?: unknown }).key === "string") {
+      map[(entry as { key: string }).key] = String((entry as { value?: unknown }).value ?? "");
+    }
+  }
+  return { ...rest, secrets: map };
 }
 
 /** Is a live resource chant-owned (by its metadata marker)? Pure. */
@@ -142,6 +167,20 @@ interface LiveResource {
   metadata?: Record<string, unknown>;
 }
 
+interface ApplyResultSecret {
+  key: string;
+  action: string;
+  errors?: Record<string, unknown> | null;
+}
+
+interface ApplyResult {
+  kind: string;
+  name: string;
+  action: string;
+  errors?: Record<string, unknown> | null;
+  secrets?: ApplyResultSecret[];
+}
+
 async function listByName(http: FountainHttp, kind: string): Promise<Map<string, LiveResource>> {
   const { status, json } = await http("GET", `/api/${KIND_PATHS[kind]}`);
   if (status !== 200) throw new Error(`fountainApply: list ${kind} failed (${status})`);
@@ -153,83 +192,46 @@ export async function fountainApply(
   args: FountainApplyArgs,
   http?: FountainHttp,
 ): Promise<FountainApplySummary> {
-  const content = args.planContent ?? readFileSync(args.planPath!, "utf-8");
-  const plan = parsePlan(content);
+  const content = args.manifestContent ?? readFileSync(args.manifestPath!, "utf-8");
+  const resources = parseManifest(content);
 
   const endpoint = resolveEndpoint(args);
   const client = http ?? defaultFountainHttp(endpoint, resolveToken(args));
 
   const summary: FountainApplySummary = { created: [], updated: [], pruned: [], secretsUpserted: 0 };
-  const idByKindAndName = new Map<string, string>();
-  const live = new Map<string, Map<string, LiveResource>>();
-  for (const kind of APPLY_ORDER) {
-    live.set(kind, await listByName(client, kind));
-  }
-
-  for (const kind of APPLY_ORDER) {
-    for (const [entityName, entry] of Object.entries(plan)) {
-      if (entry.kind !== kind) continue;
-
-      const { body, secrets } = splitSecrets(entry.spec);
-      const payload: Record<string, unknown> = { ...body };
-      // Manifest identity: the fountain resource is named after the spec's
-      // own `name` when present, else the entity name.
-      const resourceName = typeof payload.name === "string" ? (payload.name as string) : entityName;
-      payload.name = resourceName;
-
-      // Agent environment ref: the plan carries the referenced *entity*
-      // name; resolve through the id map (created this run) or live state.
-      if (kind === "Agent" && typeof payload.environment === "string") {
-        const refEntity = payload.environment as string;
-        const refPlanEntry = plan[refEntity];
-        const refResourceName =
-          refPlanEntry && typeof refPlanEntry.spec.name === "string"
-            ? (refPlanEntry.spec.name as string)
-            : refEntity;
-        const envId =
-          idByKindAndName.get(`Environment/${refEntity}`) ??
-          live.get("Environment")?.get(refResourceName)?.id;
-        if (!envId) throw new Error(`fountainApply: agent "${entityName}" references unknown environment "${refEntity}"`);
-        delete payload.environment;
-        payload.environment_id = envId;
-      }
 
-      const existing = live.get(kind)!.get(resourceName);
-      let id: string;
-      if (existing) {
-        const { status } = await client("PUT", `/api/${KIND_PATHS[kind]}/${existing.id}`, payload);
-        if (status !== 200) throw new Error(`fountainApply: update ${kind} "${resourceName}" failed (${status})`);
-        id = existing.id;
-        summary.updated.push(`${kind}/${resourceName}`);
-      } else {
-        const { status, json } = await client("POST", `/api/${KIND_PATHS[kind]}`, payload);
-        if (status !== 201 && status !== 200) {
-          throw new Error(`fountainApply: create ${kind} "${resourceName}" failed (${status})`);
-        }
-        id = (json as { data?: { id?: string } })?.data?.id ?? "";
-        summary.created.push(`${kind}/${resourceName}`);
-      }
-      idByKindAndName.set(`${kind}/${entityName}`, id);
-
-      // Secrets sub-resource: upsert-always (values are write-only upstream).
-      if (secrets.length > 0 && (kind === "Environment" || kind === "Vault")) {
-        for (const secret of secrets) {
-          const { status } = await client("POST", `/api/${KIND_PATHS[kind]}/${id}/secrets`, secret);
-          if (status !== 200 && status !== 201) {
-            throw new Error(`fountainApply: secret upsert on ${kind} "${resourceName}" failed (${status})`);
-          }
-          summary.secretsUpserted += 1;
-        }
+  if (resources.length > 0) {
+    const body = {
+      resources: resources.map((r) => ({ kind: r.kind, name: r.name, spec: toApplyPayload(r.spec) })),
+    };
+    const { status, json } = await client("POST", "/api/apply", body);
+    if (status !== 200) {
+      throw new Error(`fountainApply: POST /api/apply failed (${status})`);
+    }
+    const results = (json as { data?: { results?: ApplyResult[] } })?.data?.results ?? [];
+
+    const failures: string[] = [];
+    for (const r of results) {
+      const label = `${r.kind}/${r.name}`;
+      if (r.action === "created") summary.created.push(label);
+      else if (r.action === "updated") summary.updated.push(label);
+      else failures.push(`${label}: ${JSON.stringify(r.errors)}`);
+
+      for (const s of r.secrets ?? []) {
+        if (s.action === "upserted") summary.secretsUpserted += 1;
+        else failures.push(`${label} secret "${s.key}": ${JSON.stringify(s.errors)}`);
       }
     }
+    if (failures.length > 0) {
+      throw new Error(`fountainApply: ${failures.length} failure(s):\n  ${failures.join("\n  ")}`);
+    }
   }
 
   if (args.prune) {
-    const planned = new Set<string>();
-    for (const [entityName, entry] of Object.entries(plan)) {
-      const resourceName =
-        typeof entry.spec.name === "string" ? (entry.spec.name as string) : entityName;
-      planned.add(`${entry.kind}/${resourceName}`);
+    const planned = new Set(resources.map((r) => `${r.kind}/${r.name}`));
+    const live = new Map<string, Map<string, LiveResource>>();
+    for (const kind of APPLY_ORDER) {
+      live.set(kind, await listByName(client, kind));
     }
     // Reverse order: agents first, then vaults, then environments.
     for (const kind of [...APPLY_ORDER].reverse()) {

package/src/op/activities/index.ts

@@ -8,8 +8,8 @@ export {
   fountainApply,
   resolveEndpoint,
   resolveToken,
-  parsePlan,
-  splitSecrets,
+  parseManifest,
+  toApplyPayload,
   isChantOwned,
   defaultFountainHttp,
   DEFAULT_FOUNTAIN_BASE_URL,
@@ -19,8 +19,7 @@ export {
 export type {
   FountainApplyArgs,
   FountainApplySummary,
-  FountainPlan,
-  PlanEntry,
+  ManifestResource,
   FountainHttp,
 } from "./fountain-apply";
 

package/src/plugin.ts

@@ -81,7 +81,7 @@ export const fountainPlugin: LexiconPlugin = {
         "Declare, lint, and reconcile fountain Environments, Vaults, and Agents from a chant project",
       triggers: [
         { type: "context" as const, value: "fountain" },
-        { type: "context" as const, value: "founta.inevitable.fyi" },
+        { type: "context" as const, value: "fountain.inevitable.fyi" },
       ],
     },
     {
@@ -109,7 +109,7 @@ export const fountainPlugin: LexiconPlugin = {
     return [
       createDiffTool(
         fountainSerializer,
-        "Compare current fountain build output (fountain manifests + fountain-plan.json) against previous version",
+        "Compare current fountain build output (fountain manifest YAML) against previous version",
         "fountain",
       ),
     ];

package/src/serializer.test.ts

@@ -2,10 +2,6 @@ import { describe, expect, it } from "vitest";
 import { fountainSerializer } from "./serializer";
 import type { Declarable } from "@intentius/chant";
 
-function primary(result: unknown): string {
-  return typeof result === "string" ? result : (result as { primary: string }).primary;
-}
-
 function entity(entityType: string, props: Record<string, unknown>): Declarable {
   return { entityType, lexicon: "fountain", ...props } as unknown as Declarable;
 }
@@ -20,13 +16,11 @@ describe("fountain serializer", () => {
     expect(fountainSerializer.serialize(new Map())).toBe("");
   });
 
-  it("emits the fountain-plan.json sidecar for the applier", () => {
+  it("emits only the manifest YAML — no sidecar file", () => {
     const env = entity("Fountain::V1::Environment", { name: "e" });
     const result = fountainSerializer.serialize(new Map([["e", env]]));
-    expect(typeof result).toBe("object");
-    const files = (result as { files: Record<string, string> }).files;
-    const plan = JSON.parse(files["fountain-plan.json"]);
-    expect(plan.e.kind).toBe("Environment");
+    expect(typeof result).toBe("string");
+    expect(result).toContain("kind: Environment");
   });
 
   it("emits a fountain manifest per entity", () => {
@@ -36,7 +30,7 @@ describe("fountain serializer", () => {
       networking_config: { allowed_hosts: ["github.com"] },
     });
 
-    const out = primary(fountainSerializer.serialize(new Map([["conciergeEnv", env]])));
+    const out = fountainSerializer.serialize(new Map([["conciergeEnv", env]]));
 
     expect(out).toContain("apiVersion: fountain.dev/v1");
     expect(out).toContain("kind: Environment");
@@ -50,13 +44,11 @@ describe("fountain serializer", () => {
     const env = entity("Fountain::V1::Environment", { name: "e" });
     const vault = entity("Fountain::V1::Vault", { name: "v" });
 
-    const out = primary(
-      fountainSerializer.serialize(
-        new Map([
-          ["env", env],
-          ["vault", vault],
-        ]),
-      ),
+    const out = fountainSerializer.serialize(
+      new Map([
+        ["env", env],
+        ["vault", vault],
+      ]),
     );
 
     expect(out).toContain("---\n");
@@ -73,13 +65,11 @@ describe("fountain serializer", () => {
       environment: env,
     });
 
-    const out = primary(
-      fountainSerializer.serialize(
-        new Map([
-          ["conciergeEnv", env],
-          ["researcher", agent],
-        ]),
-      ),
+    const out = fountainSerializer.serialize(
+      new Map([
+        ["conciergeEnv", env],
+        ["researcher", agent],
+      ]),
     );
 
     expect(out).toContain("environment: conciergeEnv");
@@ -91,7 +81,7 @@ describe("fountain serializer", () => {
       description: "true",
     });
 
-    const out = primary(fountainSerializer.serialize(new Map([["v", vault]])));
+    const out = fountainSerializer.serialize(new Map([["v", vault]]));
     expect(out).toContain('description: "true"');
   });
 
@@ -103,7 +93,7 @@ describe("fountain serializer", () => {
       mcp_servers: { github: { env: { GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_PAT}" } } },
     });
 
-    const out = primary(fountainSerializer.serialize(new Map([["a", agent]])));
+    const out = fountainSerializer.serialize(new Map([["a", agent]]));
     expect(out).toContain('GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_PAT}"');
   });
 });

package/src/serializer.ts

@@ -1,4 +1,4 @@
-import type { Serializer, SerializerResult, Declarable } from "@intentius/chant";
+import type { Serializer, Declarable } from "@intentius/chant";
 import { walkValue, type SerializerVisitor } from "@intentius/chant/serializer-walker";
 import { propsOf } from "./entity-props";
 
@@ -8,8 +8,13 @@ import { propsOf } from "./entity-props";
  * single multi-document stream. The output stays `fountain apply -f`
  * compatible, so anyone can eject from chant and keep the artifacts.
  *
+ * This is also `fountainApply`'s own input now: since fountain's bulk
+ * `POST /api/apply` (BinaryBourbon/fountain#151) resolves name references
+ * server-side, there's no separate sidecar to keep in sync — the manifest
+ * YAML is the only artifact.
+ *
  * Cross-resource references (e.g. `agent.environment`) serialize to the
- * referenced entity's name — fountain's CLI resolves names to ids at apply.
+ * referenced entity's name — fountain resolves names to ids at apply.
  */
 
 const API_VERSION = "fountain.dev/v1";
@@ -24,7 +29,7 @@ export const fountainSerializer: Serializer = {
   name: "fountain",
   rulePrefix: "FTN",
 
-  serialize(entities: Map<string, Declarable>): string | SerializerResult {
+  serialize(entities: Map<string, Declarable>): string {
     // Reverse map for reference resolution: Declarable instance → name.
     const entityNames = new Map<Declarable, string>();
     for (const [name, entity] of entities) {
@@ -50,7 +55,6 @@ export const fountainSerializer: Serializer = {
     };
 
     const docs: string[] = [];
-    const plan: Record<string, { kind: string; spec: Record<string, unknown> }> = {};
     for (const [name, entity] of entities) {
       const spec: Record<string, unknown> = {};
       for (const [key, val] of Object.entries(propsOf(entity))) {
@@ -65,16 +69,9 @@ export const fountainSerializer: Serializer = {
         spec,
       };
       docs.push(toYaml(manifest));
-      plan[name] = { kind: manifest.kind, spec };
     }
 
-    const yaml = docs.join("---\n");
-    if (docs.length === 0) return yaml;
-
-    // Primary output is the ejectable `fountain apply -f` YAML; the JSON
-    // sidecar is the fountainApply op's input (same data, no YAML parser
-    // needed on the apply side — the fly plan.json pattern).
-    return { primary: yaml, files: { "fountain-plan.json": JSON.stringify(plan, null, 2) } };
+    return docs.join("---\n");
   },
 };
 

package/src/skills/chant-fountain-secrets.md

@@ -11,7 +11,7 @@ user-invocable: true
 Everything materialized into a fountain sandbox must be presumed exfiltrated once untrusted agent code runs. Order of preference:
 
 1. **`${VAR}` substitution references** in agent config (MCP server env, system prompts). Resolved at spawn from the merged environment + vault sets. Never a value in source.
-2. **Environment secrets** (`spec.secrets`) — encrypted at rest, write-only over the API (values are never returned once stored). `fountainApply` upserts them through the sub-resource; a changed value cannot be detected, only overwritten.
+2. **Environment secrets** (`spec.secrets`) — encrypted at rest, write-only over the API (values are never returned once stored). `fountainApply` sends them inline with the rest of the resource in the bulk apply request, and the server upserts them through the encrypted envelope path; a changed value cannot be detected, only overwritten.
 3. **`env_vars`** — plaintext config only. FTN012 errors on credential-shaped keys or values here.
 
 Never put a literal credential anywhere in a declaration: FTN001 catches known shapes (AWS keys, GitHub/Slack tokens, `sk-`/`ftn_` keys, private key material) at the AST; FTN015 errors on secret-shaped MCP env keys that are not `${VAR}` references.

package/src/skills/chant-fountain.md

@@ -10,7 +10,7 @@ user-invocable: true
 
 [fountain](https://github.com/BinaryBourbon/fountain) runs coding agents in sandboxed VMs. Its workload layer is three kinds — `Environment` (sandbox baseline), `Vault` (env-var overrides), `Agent` (a runnable agent config) — and this lexicon declares them as typed chant resources. Conversations are runs, not resources: start them with the `fountainRun` op, never declare them.
 
-The source of truth is the TypeScript in `src/`. `chant build` serializes it to fountain's own manifest YAML (ejectable — `fountain apply -f` accepts it verbatim) plus a `fountain-plan.json` sidecar that `fountainApply` reconciles against the API directly: create-if-new, update-by-name, opt-in owned-only prune keyed on the `managed-by: chant` metadata marker.
+The source of truth is the TypeScript in `src/`. `chant build` serializes it to fountain's own manifest YAML (ejectable — `fountain apply -f` accepts it verbatim). `fountainApply` sends that same YAML to fountain's bulk `POST /api/apply` endpoint in one request: create-if-new, update-by-name, opt-in owned-only prune keyed on the `managed-by: chant` metadata marker.
 
 ## Authoring
 

package/src/spec/fetch.ts

@@ -23,7 +23,7 @@ import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { fetchWithCache } from "@intentius/chant/codegen/fetch";
 
-const SCHEMA_URL = "https://founta.inevitable.fyi/api/openapi.json";
+const SCHEMA_URL = "https://fountain.inevitable.fyi/api/openapi.json";
 
 const CACHE_FILE = join(homedir(), ".chant", "fountain-openapi.json");