@usenaive-sdk/blueprints 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -80,6 +80,8 @@ declare const AppDeclSchema: z.ZodObject<{
     mcp: z.ZodOptional<z.ZodString>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         from_env: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        generate: z.ZodLiteral<true>;
     }, z.core.$strip>]>>>;
 }, z.core.$strip>;
 /**
@@ -252,6 +254,8 @@ declare const ProjectSchema: z.ZodObject<{
         mcp: z.ZodOptional<z.ZodString>;
         env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             from_env: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            generate: z.ZodLiteral<true>;
         }, z.core.$strip>]>>>;
     }, z.core.$strip>>>;
     agents: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -391,6 +395,50 @@ declare function collectFiles(source: FileSource): Record<string, string>;
  */
 declare function contentHash(files: Record<string, string>): string;
 
+/**
+ * The blueprint install (`canonical-spec §29.6`) — one applied declaration per
+ * (organization, project), and the drift a `revision_conflict` names.
+ *
+ * `naive up` needed no server-side state while the only writer was a person with a clone: its
+ * working tree was the manifest. The studio applying the same declaration makes two writers on one
+ * organization, and neither can see the other. This row is what they share.
+ *
+ * It is not a second source of truth for what is provisioned — apps, agents, skills, identities and
+ * vaults stay keyed by name on their own routes. It records *that* an apply happened, with what, by
+ * whom, and against which revision.
+ */
+
+/**
+ * What one apply did to one resource. This is the vocabulary `naive up` has printed since it
+ * existed; it is written HERE, and imported by `@usenaive-sdk/blueprints`, for the reason
+ * `CLAUDE.md §2` gives: the hosted apply publishes the engine's report on the install (below), so
+ * it is a wire shape, and a wire shape has exactly one definition. The engine re-exports these two
+ * names unchanged, so nothing downstream of it learns a second word for the same thing.
+ */
+declare const ResourceActionSchema: z.ZodEnum<{
+    created: "created";
+    updated: "updated";
+    unchanged: "unchanged";
+    deleted: "deleted";
+    refused: "refused";
+}>;
+type ResourceAction = z.infer<typeof ResourceActionSchema>;
+/** One line of an apply: what was named, what happened to it, and — for a refusal — why. */
+declare const ResourceReportSchema: z.ZodObject<{
+    name: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        unchanged: "unchanged";
+        deleted: "deleted";
+        refused: "refused";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ResourceReportLine = z.infer<typeof ResourceReportSchema>;
+
 /**
  * The report vocabulary `up` speaks (`workstreams/10-blueprints.md §2` item 4) and the handful of
  * client-side moves every resource kind shares: one line per attempt with refusals caught into
@@ -398,14 +446,62 @@ declare function contentHash(files: Record<string, string>): string;
  * cursor pagination, and the by-name tombstone behind `removed`.
  */
 
-type ResourceAction = "created" | "updated" | "unchanged" | "deleted" | "refused";
-interface ResourceReport {
-    name: string;
-    action: ResourceAction;
-    id?: string;
-    url?: string | null;
-    /** Why, for `refused`; what would happen, for a dry-run line that needs explaining. */
-    reason?: string;
+type ResourceReport = ResourceReportLine;
+
+/**
+ * Apps in `naive up`: upsert by `GET /v1/apps?name=` (§29.2), `env` written as write-only secrets
+ * only when the live `value_hash` differs from the local one (ADR-0354, ADR-0357), and the
+ * `deploy_dir` shipped only when its content hash differs from the newest live deployment's
+ * (ADR-0357). Live secret names the config does not declare are reported, never deleted
+ * (ADR-0352). `mcp` is patched on drift, absent meaning `null` (§29.5); the platform mints the
+ * app's `VETTA_MCP_TOKEN` itself, so nothing here ever holds that token.
+ *
+ * A hosted apply also arrives with a PLATFORM ENVIRONMENT (`PlatformEnv`, §29.7) — the base URL, the
+ * identity the install runs as, and a scoped key it will mint for an app that asks. That layer is
+ * read before `{ from_env }`'s own environment, and a declaration may ask for a value nobody has
+ * with `{ generate: true }`. Both are provisioned ONCE per app, because a value the platform invents
+ * has no stable digest and rewriting it every apply would rotate a live credential.
+ *
+ * An app also records the project that made it (ADR-0375), and that stamp is compared before any
+ * write: a name this project does not own is refused rather than adopted, which is what standing
+ * up a second blueprint did to the first one's live deployment.
+ */
+
+/** The platform environment's variable names (`canonical-spec §29.7`) — fixed, never inferred. */
+declare const PLATFORM_ENV: {
+    /** The base URL of the API this apply ran through. */
+    readonly api_url: "NAIVE_API_URL";
+    /** The identity the install runs as, when the declaration declares exactly one. */
+    readonly identity_id: "NAIVE_IDENTITY_ID";
+    /** A scoped organization API key minted for the app that asks for it. */
+    readonly api_key: "NAIVE_API_KEY";
+};
+/**
+ * WHAT THE PLATFORM PROVIDES A HOSTED APPLY, AND THE ONE DISTINCTION THAT MATTERS
+ * (`canonical-spec §29.7`).
+ *
+ * Absent on a laptop apply, which reads the author's shell and nothing else — the hosted path gains
+ * a layer, the local path does not lose one.
+ *
+ * **What the platform KNOWS it always tells the app; what the platform must INVENT it invents only
+ * on request, and only once.** That is not a stylistic split. A known value has a stable digest, so
+ * the `value_hash` compare that makes `naive up` idempotent (§29.2) can say `unchanged` about it and
+ * re-asserting it every apply costs nothing. An invented one never matches its own previous digest,
+ * so re-inventing it every apply would rotate a live credential under a build that still holds the
+ * old one — and, for a minted key, leave one dead `api_key` row behind per apply.
+ */
+interface PlatformEnv {
+    /**
+     * Values the platform knows. Written to every app this apply deploys that declares an `env` —
+     * whether or not the declaration names them, which is the `VETTA_MCP_TOKEN` precedent (§29.2) —
+     * and read FIRST by a `{ from_env }` that does name them.
+     */
+    known: Record<string, string>;
+    /**
+     * Values the platform must invent, by variable name, given the app that asked. Called at most
+     * once per app, and only when that app holds no secret of that name.
+     */
+    minted?: Record<string, (app: string) => Promise<string>>;
 }
 
 /**
@@ -460,8 +556,43 @@ interface UpOptions {
      * (ADR-0375). Off by default — adopting by default is what overwrote a live deployment.
      */
     adopt?: boolean;
+    /**
+     * The built trees, by app name, for an apply that runs where there is no checkout: the platform
+     * applying a published artifact on an operator's behalf (`canonical-spec §31.1`). The bytes come
+     * out of the artifact's object-store entry, in the same file map `deploy_dir` would have been
+     * collected into — which is why `collectFiles` takes both and there is one digest (`files.ts`).
+     *
+     * Present ⇒ the disk is never read for an app, and an app whose tree is not in the map is refused
+     * by name rather than deployed empty. Absent ⇒ `dir` + `deploy_dir`, exactly as before.
+     */
+    trees?: Record<string, Record<string, string>>;
+    /**
+     * Why a declared app is absent from `trees`, by app name — an object-store read that failed
+     * rather than an object that was never uploaded. Both come out of `builtTree` as one refusal;
+     * only the caller that did the reading can tell them apart, so only it can say (`apps.ts`).
+     */
+    tree_errors?: Record<string, string>;
+    /**
+     * What an app's `{ from_env }` reads (`apps.ts`). The process's own environment by default —
+     * the author's shell, which is the whole point of `from_env` on a laptop. A hosted apply has no
+     * shell and passes the operator's **answers** instead (`canonical-spec §31.2`): the same
+     * declaration, resolved against the only environment that apply has.
+     */
+    env?: Record<string, string | undefined>;
+    /**
+     * THE PLATFORM ENVIRONMENT (`canonical-spec §29.7`) — what the platform itself provides an app,
+     * read BEFORE `env` and written whether or not the declaration names it.
+     *
+     * Present only on a hosted apply, and that is the whole of the local/hosted difference: `naive up`
+     * from a checkout passes none, reads the author's shell, and behaves exactly as it always has.
+     *
+     * `NAIVE_IDENTITY_ID` is filled in here rather than by the caller, because the id does not exist
+     * until this run has created the identity — identities are upserted before apps for the same
+     * reason agents reference them by name.
+     */
+    platform?: PlatformEnv;
 }
 /** Plan → apply → report. Every refusal is one line in the report, never a thrown escape. */
 declare function up(config: Readonly<ProjectConfig>, client: VettaClient, opts?: UpOptions): Promise<UpReport>;
 
-export { type AgentDecl, type AppDecl, BLUEPRINTS, BlueprintRefusal, CONFIG_CANDIDATES, type ConfigLoad, type CredentialDecl, type DefineInput, type FileSource, type IdentityDecl, type ProjectConfig, type ResourceAction, type ResourceReport, type ScheduleDecl, type SkillDecl, type Template, type TemplateChoice, type TemplateKind, type UpOptions, type UpReport, type VaultDecl, chooseTemplate, collectFiles, contentHash, defineProject, loadConfig, parseProject, up };
+export { type AgentDecl, type AppDecl, BLUEPRINTS, BlueprintRefusal, CONFIG_CANDIDATES, type ConfigLoad, type CredentialDecl, type DefineInput, type FileSource, type IdentityDecl, PLATFORM_ENV, type PlatformEnv, type ProjectConfig, type ResourceAction, type ResourceReport, type ScheduleDecl, type SkillDecl, type Template, type TemplateChoice, type TemplateKind, type UpOptions, type UpReport, type VaultDecl, chooseTemplate, collectFiles, contentHash, defineProject, loadConfig, parseProject, up };

package/dist/index.js

@@ -93,6 +93,8 @@ var AUDIT_ACTIONS_P3 = [
   "app.domain_connected",
   "app.domain_disconnected",
   "app.db_queried",
+  /** A ticket was minted that lets one browser past an app's own operator gate (§29.7). */
+  "app.entered",
   "blueprint.installed"
 ];
 var AUDIT_ACTIONS = [
@@ -817,6 +819,11 @@ var AppSecretSchema = z11.object({
   value_hash: z11.string().nullable(),
   created_at: Timestamp
 });
+var AppEntrySchema = z11.object({
+  object: z11.literal("app_entry"),
+  url: z11.string(),
+  ticket: z11.string()
+});
 var AppDomainStatusSchema = z11.enum(["pending", "connected", "failed"]);
 var AppDomainSchema = z11.object({
   object: z11.literal("app_domain"),
@@ -832,6 +839,26 @@ var APP_NAME = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
 // ../core/src/schema/install.ts
 import { z as z12 } from "zod";
 var BlueprintInstallSourceSchema = z12.enum(["studio", "cli"]);
+var ResourceActionSchema = z12.enum(["created", "updated", "unchanged", "deleted", "refused"]);
+var ResourceReportSchema = z12.object({
+  name: z12.string().min(1),
+  action: ResourceActionSchema,
+  /** The `agt_`/`app_`/`ses_`… the line resolved to. Absent on a refusal that never got an id. */
+  id: z12.string().optional(),
+  /** An app's hostname once its build went live; `null` while it has none. Apps only. */
+  url: z12.string().nullable().optional(),
+  reason: z12.string().optional()
+});
+var BlueprintReportSchema = z12.object({
+  skills: z12.array(ResourceReportSchema),
+  identities: z12.array(ResourceReportSchema),
+  vaults: z12.array(ResourceReportSchema),
+  apps: z12.array(ResourceReportSchema),
+  agents: z12.array(ResourceReportSchema),
+  schedules: z12.array(ResourceReportSchema),
+  intake: z12.array(ResourceReportSchema),
+  skipped: z12.array(z12.string())
+});
 var BlueprintInstallSchema = z12.object({
   id: idOf("bpi"),
   object: z12.literal("blueprint_install"),
@@ -869,6 +896,19 @@ var BlueprintInstallSchema = z12.object({
    * has it, so nothing is lost by not saying it twice.
    */
   source: BlueprintInstallSourceSchema,
+  /**
+   * WHAT THE APPLY DID, or `null` when it did nothing but record.
+   *
+   * An apply that sends its own `declaration` has already reconciled it — that is what `naive up`
+   * is — so the row it writes is a record and this is `null`. An apply that names a **published**
+   * pair has reconciled nothing: it was never given the bytes (§31.1), so the server reads them
+   * from the catalog and runs the same engine over them, and this is what that run reported.
+   *
+   * It is stored rather than only returned because a refusal inside a successful apply — an app
+   * whose `env` reads a variable no hosted run has, a session refused for credit — is the one fact
+   * a person needs after the screen that showed it is gone.
+   */
+  report: BlueprintReportSchema.nullable(),
   applied_at: Timestamp,
   created_at: Timestamp
 });
@@ -895,6 +935,11 @@ var BlueprintAppSchema = z13.object({
   description: z13.string().nullable()
 });
 var ContentHashSchema = z13.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
+var BlueprintTreeSchema = z13.object({
+  /** `apps[].name` in the declaration — the same name §31.5 prints and the install ensures by. */
+  app: z13.string().min(1),
+  content_hash: ContentHashSchema
+});
 var BlueprintArtifactSchema = z13.object({
   id: idOf("bpa"),
   object: z13.literal("blueprint_artifact"),
@@ -904,7 +949,12 @@ var BlueprintArtifactSchema = z13.object({
   template: z13.string().min(1),
   /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
   version: z13.string().min(1),
-  content_hash: ContentHashSchema,
+  /**
+   * The built trees, one per deployable app, ordered as the declaration orders its apps. Never
+   * empty: an artifact that built nothing is not an artifact, and the column behind it says so
+   * (migration 0040) exactly as the single `content_hash` it replaces was `not null`.
+   */
+  trees: z13.array(BlueprintTreeSchema).min(1),
   /**
    * The setup questions, asked by the studio **before** provisioning. `QuestionField` (§7.1) is
    * reused rather than restated: a setup question and a question a parked agent asks are the same
@@ -1065,7 +1115,11 @@ function chooseTemplate(blueprint, template) {
 var BlueprintRefusal = class extends Error {
   name = "BlueprintRefusal";
 };
-var EnvValueSchema = z16.union([z16.string(), z16.object({ from_env: z16.string().min(1) })]);
+var EnvValueSchema = z16.union([
+  z16.string(),
+  z16.object({ from_env: z16.string().min(1) }),
+  z16.object({ generate: z16.literal(true) })
+]);
 var AppDeclSchema = z16.object({
   /** Becomes a hostname, so the grammar is the platform's `APP_NAME` (a DNS label). */
   name: z16.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
@@ -1458,7 +1512,7 @@ async function tombstone(name, current, remove, dryRun) {
 
 // src/agents.ts
 function desiredTools(decl, current, ids) {
-  if (decl.allowed_apps === void 0) return decl.tools;
+  if (ids === void 0) return decl.tools;
   const base = decl.tools ?? current?.tools ?? { default_config: { permission: "allow" }, configs: {} };
   const appsTool = base.configs["apps"] ?? { enabled: true, permission: base.default_config.permission };
   return {
@@ -1483,14 +1537,14 @@ async function createAgent(client, decl, tools, identityId) {
   if (identityId !== void 0) await client.identities.attach(created.id, identityId);
   return { name: decl.name, action: "created", id: created.id };
 }
-async function upsertAgent(client, decl, existing, ids, dryRun) {
+async function upsertAgent(client, decl, existing, ids, dryRun, scoped) {
   const unresolved = (decl.allowed_apps ?? []).filter((name) => !ids.apps.has(name));
   const identityId = decl.identity === void 0 ? void 0 : ids.identities.get(decl.identity);
   const missing = unresolved.length > 0 ? `allowed_apps needs app "${unresolved[0]}"` : decl.identity !== void 0 && identityId === void 0 ? `identity needs "${decl.identity}"` : null;
   if (missing !== null && !dryRun) {
     return { name: decl.name, action: "refused", reason: `${missing}, which was not provisioned in this run` };
   }
-  const appIds = (decl.allowed_apps ?? []).flatMap((name) => ids.apps.get(name) ?? []);
+  const appIds = decl.allowed_apps !== void 0 ? decl.allowed_apps.flatMap((name) => ids.apps.get(name) ?? []) : scoped;
   const current = existing.find((agent) => agent.name === decl.name) ?? null;
   const tools = desiredTools(decl, current, appIds);
   if (!current) return dryRun ? { name: decl.name, action: "created" } : createAgent(client, decl, tools, identityId);
@@ -1563,7 +1617,7 @@ async function reconcileSchedules(client, agent, declared, live, identityIds, dr
 }
 
 // src/apps.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash2, randomBytes } from "node:crypto";
 import { resolve as resolve2 } from "node:path";
 async function findApp(client, name, skipped) {
   const rows = await listAll(client.config, "/v1/apps", AppSchema, skipped, { name });
@@ -1575,25 +1629,74 @@ function ownershipRefusal(name, project, owner) {
   return `app "${name}" is owned by ${held}; this project is "${project}". Rename the app in your config, or re-run \`naive up --adopt\` to ${verb} it.`;
 }
 var ensureApp = (client, body) => client.apps.create(body);
-function resolveEnv(decl) {
-  const env = {};
-  for (const [name, value] of Object.entries(decl.env ?? {})) {
+var PLATFORM_ENV = {
+  /** The base URL of the API this apply ran through. */
+  api_url: "NAIVE_API_URL",
+  /** The identity the install runs as, when the declaration declares exactly one. */
+  identity_id: "NAIVE_IDENTITY_ID",
+  /** A scoped organization API key minted for the app that asks for it. */
+  api_key: "NAIVE_API_KEY"
+};
+function planEnv(decl, opts) {
+  if (decl.env === void 0) return [];
+  const plan = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(decl.env)) {
     if (typeof value === "string") {
-      env[name] = value;
+      plan.set(name, { name, value });
       continue;
     }
-    const local = process.env[value.from_env];
-    if (local === void 0) throw new Error(`env ${name} reads local variable ${value.from_env}, which is not set`);
-    env[name] = local;
+    if ("generate" in value) {
+      plan.set(name, { name, invent: async () => generated() });
+      continue;
+    }
+    const known = opts.platform?.known[value.from_env];
+    const mint = opts.platform?.minted?.[value.from_env];
+    if (known !== void 0) plan.set(name, { name, value: known });
+    else if (mint !== void 0) plan.set(name, { name, invent: () => mint(decl.name) });
+    else {
+      const local = opts.env[value.from_env];
+      if (local === void 0) throw new Error(`env ${name} reads local variable ${value.from_env}, which is not set`);
+      plan.set(name, { name, value: local });
+    }
   }
-  return env;
+  for (const [name, value] of Object.entries(opts.platform?.known ?? {})) plan.set(name, { name, value });
+  return [...plan.values()];
 }
+async function materialize(plan, held, dryRun) {
+  const values = {};
+  const unmade = [];
+  for (const one of plan) {
+    if (one.value !== void 0) values[one.name] = one.value;
+    else if (held.has(one.name)) continue;
+    else if (dryRun) unmade.push(one.name);
+    else values[one.name] = await invent(one);
+  }
+  return { values, unmade };
+}
+async function invent(one) {
+  try {
+    return await one.invent();
+  } catch (cause) {
+    throw new Error(
+      `env ${one.name} is provisioned by the platform, and could not be: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+  }
+}
+var generated = () => randomBytes(32).toString("base64url");
+var EMPTY = /* @__PURE__ */ new Set();
 function secretHash(name, value) {
   return createHash2("sha256").update(`${name}\0`).update(value).digest("hex");
 }
-function localTree(decl, dir) {
+function builtTree(decl, opts) {
   if (!decl.deploy_dir) return null;
-  const files = collectFiles(resolve2(dir, decl.deploy_dir));
+  const hosted = opts.trees;
+  if (hosted !== void 0 && hosted[decl.name] === void 0) {
+    const failed = opts.tree_errors?.[decl.name];
+    throw new Error(
+      `app "${decl.name}" declares deploy_dir "${decl.deploy_dir}", but this apply was handed no built tree for it` + (failed === void 0 ? "" : `: ${failed}`)
+    );
+  }
+  const files = collectFiles(hosted?.[decl.name] ?? resolve2(opts.dir, decl.deploy_dir));
   return { files, hash: contentHash(files) };
 }
 async function writeApp(client, id, env, tree) {
@@ -1613,7 +1716,7 @@ async function settleDeploy(client, id) {
     await new Promise((resolve4) => setTimeout(resolve4, SETTLE_MS));
   }
 }
-async function createApp(client, decl, env, opts, appIds) {
+async function createApp(client, decl, env, tree, opts, appIds) {
   const created = await ensureApp(client, {
     name: decl.name,
     type: decl.type,
@@ -1622,12 +1725,12 @@ async function createApp(client, decl, env, opts, appIds) {
     ...decl.mcp !== void 0 ? { mcp: decl.mcp } : {}
   });
   appIds.set(decl.name, created.id);
-  await writeApp(client, created.id, env, localTree(decl, opts.dir));
+  await writeApp(client, created.id, env, tree);
   return { name: decl.name, action: "created", id: created.id, url: (await client.apps.get(created.id)).url };
 }
 async function upsertApp(client, decl, opts, appIds) {
-  const env = resolveEnv(decl);
-  const names = Object.keys(env);
+  const declared = planEnv(decl, opts);
+  const names = declared.map((one) => one.name);
   const note = (notes) => notes.length > 0 ? { reason: notes.join("; ") } : {};
   const mcpPlan = decl.mcp !== void 0 ? [`will set mcp ${decl.mcp}`] : [];
   const current = await findApp(client, decl.name, opts.skipped);
@@ -1640,7 +1743,8 @@ async function upsertApp(client, decl, opts, appIds) {
         ...note([...willSet, ...mcpPlan, ...decl.deploy_dir ? [`will deploy ${decl.deploy_dir}`] : []])
       };
     }
-    return createApp(client, decl, env, opts, appIds);
+    const { values } = await materialize(declared, EMPTY, false);
+    return createApp(client, decl, values, builtTree(decl, opts), opts, appIds);
   }
   const owned = current.project === opts.project;
   if (!owned && !opts.adopt) {
@@ -1665,19 +1769,21 @@ async function upsertApp(client, decl, opts, appIds) {
   if (!owned && !opts.dryRun) {
     await ensureApp(client, { name: decl.name, type: decl.type, project: opts.project, adopt: true });
   }
-  const live = decl.env === void 0 ? [] : (await client.apps.secrets(current.id)).data;
-  const unmanaged = live.map((secret) => secret.name).filter((name) => !(name in env));
+  const live = declared.length === 0 ? [] : (await client.apps.secrets(current.id)).data;
+  const managed = new Set(names);
+  const unmanaged = live.map((secret) => secret.name).filter((name) => !managed.has(name));
   const held = new Map(live.map((secret) => [secret.name, secret.value_hash]));
+  const { values: env, unmade } = await materialize(declared, new Set(held.keys()), opts.dryRun);
   const staleEnv = Object.fromEntries(
     Object.entries(env).filter(([name, value]) => held.get(name) !== secretHash(name, value))
   );
-  const staleNames = Object.keys(staleEnv);
+  const staleNames = [...Object.keys(staleEnv), ...unmade];
   const patch = {
     ...decl.description !== void 0 && decl.description !== current.description ? { description: decl.description } : {},
     ...(decl.mcp ?? null) !== current.mcp ? { mcp: decl.mcp ?? null } : {}
   };
   const drifted = Object.keys(patch).length > 0;
-  const tree = localTree(decl, opts.dir);
+  const tree = builtTree(decl, opts);
   const newest = tree ? (await client.apps.deployments(current.id, { limit: 1 })).data[0] : void 0;
   const stale = tree !== null && newest?.content_hash !== tree.hash;
   const action = !owned || drifted || stale || staleNames.length > 0 ? "updated" : "unchanged";
@@ -1725,14 +1831,14 @@ async function upsertVault(client, decl, existing, identityIds, dryRun) {
   }
   return { name: decl.name, action: "unchanged", id: current.id };
 }
-async function upsertCredential(client, vault, decl, existing, dryRun) {
+async function upsertCredential(client, vault, decl, existing, dryRun, from) {
   const name = `${vault.name} / ${decl.key}`;
   if (vault.action === "refused") throw new Error(`vault "${vault.name}" was not provisioned in this run`);
   const current = existing.find(
     (row) => row.kind === decl.kind && row.key === decl.key && row.host === (decl.host ?? null) && row.mcp_server_url === (decl.mcp_server_url ?? null)
   );
   if (current) return { name, action: "unchanged", id: current.id };
-  const value = process.env[decl.value.from_env];
+  const value = from[decl.value.from_env];
   if (value === void 0) throw new Error(`credential ${decl.key} reads local variable ${decl.value.from_env}, which is not set`);
   if (dryRun || vault.id === void 0) return { name, action: "created" };
   const created = await client.vaults.credentials.create(vault.id, {
@@ -1746,7 +1852,17 @@ async function upsertCredential(client, vault, decl, existing, dryRun) {
 }
 
 // src/up.ts
+function identityEnv(config, ids) {
+  if (config.identities.length !== 1) return {};
+  const id = ids.get(config.identities[0].name);
+  return id === void 0 ? {} : { [PLATFORM_ENV.identity_id]: id };
+}
 async function upsertSkill(client, decl, opts) {
+  if (opts.hosted) {
+    throw new Error(
+      `skill "${decl.slug}" is declared as the file "${decl.file}", and a hosted apply has no checkout to read it from. Push it with \`naive up\` from a clone, or publish it as part of the blueprint.`
+    );
+  }
   const content = readFileSync3(resolve3(opts.dir, decl.file), "utf8");
   const sha256 = createHash3("sha256").update(content).digest("hex");
   const current = await absent(client.skills.get(decl.slug));
@@ -1825,8 +1941,9 @@ async function up(config, client, opts = {}) {
   const ids = { apps: /* @__PURE__ */ new Map(), identities: /* @__PURE__ */ new Map() };
   const report = { dry_run: dryRun, ...applied(config), skills: [], identities: [], vaults: [], apps: [], agents: [], schedules: [], intake: [], skipped: [] };
   const owner = { project: config.name, adopt: opts.adopt ?? false, skipped: report.skipped };
+  const hosted = opts.trees !== void 0;
   for (const decl of config.skills) {
-    await attempt(report.skills, decl.slug, () => upsertSkill(client, decl, { dryRun, dir }));
+    await attempt(report.skills, decl.slug, () => upsertSkill(client, decl, { dryRun, dir, hosted }));
   }
   for (const decl of config.identities) {
     await attempt(report.identities, decl.name, () => upsertIdentity(client, decl, dryRun, ids.identities));
@@ -1837,17 +1954,39 @@ async function up(config, client, opts = {}) {
     const vaultId = line.action === "unchanged" ? line.id : void 0;
     const rows = vaultId === void 0 ? [] : await listAll(client.config, `/v1/vaults/${vaultId}/credentials`, VaultCredentialSchema, report.skipped);
     for (const cred of decl.credentials) {
-      await attempt(report.vaults, `${decl.name} / ${cred.key}`, () => upsertCredential(client, line, cred, rows, dryRun));
+      await attempt(
+        report.vaults,
+        `${decl.name} / ${cred.key}`,
+        () => upsertCredential(client, line, cred, rows, dryRun, opts.env ?? process.env)
+      );
     }
   }
+  const platform = opts.platform && {
+    ...opts.platform,
+    known: { ...opts.platform.known, ...identityEnv(config, ids.identities) }
+  };
   for (const decl of config.apps) {
-    await attempt(report.apps, decl.name, () => upsertApp(client, decl, { ...owner, dryRun, dir }, ids.apps));
+    await attempt(
+      report.apps,
+      decl.name,
+      () => upsertApp(
+        client,
+        decl,
+        { ...owner, dryRun, dir, trees: opts.trees, tree_errors: opts.tree_errors, env: opts.env ?? process.env, platform },
+        ids.apps
+      )
+    );
   }
   const existing = config.agents.length > 0 || config.removed.agents.length > 0 || config.kept.agents.length > 0 ? await listAll(client.config, "/v1/agents", AgentSchema, report.skipped) : [];
   const deployments = config.agents.some((decl) => decl.schedules !== void 0) ? await listAll(client.config, "/v1/deployments", DeploymentSchema, report.skipped) : [];
+  const scoped = config.apps.length > 0 ? [...ids.apps.values()] : void 0;
   const briefed = [];
   for (const decl of config.agents) {
-    const line = await attempt(report.agents, decl.name, () => upsertAgent(client, decl, existing, ids, dryRun));
+    const line = await attempt(
+      report.agents,
+      decl.name,
+      () => upsertAgent(client, decl, existing, ids, dryRun, scoped)
+    );
     if (decl.schedules !== void 0) {
       await reconcileSchedules(client, line, decl.schedules, deployments, ids.identities, dryRun, report.schedules);
     }
@@ -1864,6 +2003,7 @@ export {
   BLUEPRINTS,
   BlueprintRefusal,
   CONFIG_CANDIDATES,
+  PLATFORM_ENV,
   chooseTemplate,
   collectFiles,
   contentHash,