@usenaive-sdk/blueprints 0.10.0 → 0.11.0

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  BLUEPRINTS,
+  chooseTemplate
+} from "./chunk-CVZ2DY27.js";
+
 // ../core/src/id.ts
 var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
 var SUFFIX_LENGTH = 26;
@@ -157,6 +162,7 @@ var AUDIT_ACTIONS_P1 = [
   "org.updated",
   "subscription.updated",
   "subscription.canceled",
+  "subscription.plan_changed",
   "session.budget_updated",
   "session.cancelled",
   "skill.created",
@@ -218,6 +224,9 @@ var AUDIT_ACTIONS_P3 = [
   "referral.attributed"
 ];
 var AUDIT_ACTIONS_PRIMITIVES = [
+  "ad_campaign.created",
+  "ad_campaign.activated",
+  "ad_campaign.paused",
   "legal_verification.started",
   "legal_member.completed",
   "legal_member.link_resent",
@@ -280,7 +289,7 @@ var JsonSchemaDocument = z.record(z.string(), z.unknown()).refine((schema) => sc
 var WindowSchema = z.enum(["immediate", "priority", "loose"]);
 var TOKEN_TIERS = ["input", "cache_write", "cache_read", "output", "reasoning"];
 var TokenTierSchema = z.enum(TOKEN_TIERS);
-var TOOL_TIERS = ["search", "media", "social", "browser", "storage", "email"];
+var TOOL_TIERS = ["search", "media", "social", "browser", "storage", "email", "voice"];
 var LINE_ITEM_TIERS = [...TOKEN_TIERS, "computer", ...TOOL_TIERS];
 var LineItemTierSchema = z.enum(LINE_ITEM_TIERS);
 var TokenUsageSchema = z.object({
@@ -328,6 +337,12 @@ var TimezoneSchema = z3.string().transform((name, ctx) => {
   }
   return zone;
 });
+var BRAND_TYPEFACES = ["grotesk", "serif", "rounded", "mono"];
+var BrandKitSchema = z3.object({
+  palette: z3.array(z3.object({ name: z3.string().trim().min(1).max(24), hex: z3.string().regex(/^#[0-9a-f]{6}$/) }).strict()).min(3).max(6),
+  typeface: z3.enum(BRAND_TYPEFACES),
+  tagline: z3.string().trim().max(80)
+}).strict();
 var OrganizationSchema = z3.object({
   id: idOf("org"),
   object: z3.literal("organization"),
@@ -345,6 +360,15 @@ var OrganizationSchema = z3.object({
    * until one is set. Defaulted so a reply from a control plane older than 0093 still parses.
    */
   logo_svg: z3.string().nullable().default(null),
+  /** Its brand kit (ADR-1163), `null` until one is set. Defaulted so an older control plane parses. */
+  brand: BrandKitSchema.nullable().default(null),
+  /**
+   * Still being set up: made in a chat with its CEO and not yet activated by a payment (ADR-1108).
+   * Defaulted `false`, so a reply from a control plane older than 0101 reads as an ordinary company.
+   */
+  setting_up: z3.boolean().default(false),
+  /** The `blueprint/template` a link named when the company was made, else `null` (ADR-1108). */
+  start_template: z3.string().nullable().default(null),
   created_at: Timestamp
 });
 var RoleSchema = z3.enum(["owner", "admin", "member"]);
@@ -664,7 +688,35 @@ var BudgetSchema = z6.object({
 var SkillRefSchema = z6.string().regex(/^(naive\/)?[a-z0-9][a-z0-9-]*(@\d+)?$/, {
   error: "expected `slug`, `slug@N`, `naive/slug` or `naive/slug@N`"
 });
+var SECRET_HEADER = /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|x-auth-token)$/i;
 var McpServerSchema = z6.object({
+  name: z6.string().min(1).max(64),
+  url: z6.url().startsWith("https://", { error: "an MCP server URL must be HTTPS" }),
+  headers: z6.record(z6.string().max(128), z6.string().max(4096)).optional()
+}).superRefine((server, ctx) => {
+  let url = null;
+  try {
+    url = new URL(server.url);
+  } catch {
+  }
+  if (url && (url.username !== "" || url.password !== "")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["url"],
+      message: "credentials belong in a vault-bound MCP credential, not the server URL"
+    });
+  }
+  for (const name of Object.keys(server.headers ?? {})) {
+    if (SECRET_HEADER.test(name)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["headers", name],
+        message: "credentials belong in a vault-bound MCP credential, not agent config"
+      });
+    }
+  }
+});
+var StoredMcpServerSchema = z6.object({
   name: z6.string(),
   url: z6.url(),
   headers: z6.record(z6.string(), z6.string()).optional()
@@ -702,7 +754,7 @@ var agentConfigShape = {
   window: WindowSchema,
   system: z6.string(),
   tools: ToolsetSchema,
-  mcp_servers: z6.array(McpServerSchema),
+  mcp_servers: z6.array(StoredMcpServerSchema),
   skills: z6.array(SkillRefSchema),
   multiagent: MultiagentField,
   /** Optional on the type so a version minted before §28.15 still parses; read it through `handoffsOf`. */
@@ -1772,7 +1824,7 @@ var AppPermissionsSchema = z15.object({
 // ../core/src/schema/install.ts
 import { z as z16 } from "zod";
 var BlueprintInstallSourceSchema = z16.enum(["studio", "cli"]);
-var BlueprintInstallStatusSchema = z16.enum(["pending", "applied", "failed"]);
+var BlueprintInstallStatusSchema = z16.enum(["held", "pending", "applied", "failed"]);
 var ResourceActionSchema = z16.enum(["created", "updated", "unchanged", "deleted", "refused"]);
 var ResourceReportSchema = z16.object({
   name: z16.string().min(1),
@@ -1909,264 +1961,79 @@ var ProjectContextSchema = z16.object({
 });
 
 // ../core/src/schema/blueprint.ts
-import { z as z17 } from "zod";
-var BlueprintScheduleSchema = z17.object({
-  agent: z17.string().min(1),
-  cron: z17.string().min(1),
-  timezone: z17.string().nullable(),
-  /** The message each fire opens its session with — the sentence worth printing. */
-  input: z17.string().min(1),
-  budget_micro_usd: MicroUsdField.nonnegative()
-});
-var BlueprintBudgetSchema = BlueprintScheduleSchema.pick({ agent: true, cron: true, budget_micro_usd: true });
-var BlueprintCrewSchema = z17.object({
-  name: z17.string().min(1),
-  description: z17.string().nullable(),
-  model: z17.string().min(1),
-  briefed: z17.boolean(),
-  intake: z17.string().nullable().optional(),
-  /** What the first session may spend: the intake's own cap, else the agent's (§31.4). Set iff `briefed`. */
-  intake_micro_usd: MicroUsdField.nonnegative().optional(),
-  role: z17.string().min(1).optional(),
-  skills: z17.array(SkillRefSchema).optional(),
-  tools: z17.array(z17.string().min(1)).optional(),
-  required: z17.boolean().optional()
-});
-var BlueprintAppSchema = z17.object({
-  name: z17.string().min(1),
-  type: AppTypeSchema,
-  description: z17.string().nullable(),
-  mcp: z17.string().nullable().optional(),
-  tools: z17.array(z17.string().min(1)).optional(),
-  /** Whether an install may deselect it (§31.2). Optional: the rollout argument above. */
-  required: z17.boolean().optional()
-});
-var BlueprintIdentitySchema = z17.object({
-  name: z17.string().min(1),
-  description: z17.string().nullable()
-});
-var ContentHashSchema = z17.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
-var BlueprintTreeSchema = z17.object({
-  /** `apps[].name` in the declaration — the same name §31.5 prints and the install ensures by. */
-  app: z17.string().min(1),
-  content_hash: ContentHashSchema
-});
-var BlueprintArtifactSchema = z17.object({
-  id: idOf("bpa"),
-  object: z17.literal("blueprint_artifact"),
-  /** The machine — its repository, screens and `/api/*`. */
-  blueprint: z17.string().min(1),
-  /** Which of that blueprint's templates provides the crew. */
-  template: z17.string().min(1),
-  /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
-  version: z17.string().min(1),
-  /**
-   * What a person calls the template, one line on what its crew does, and the networks it publishes
-   * to — printed, never provisioned (§31.5, ADR-0921). `platforms` is decoration: where the crew
-   * posts is the accounts connected to its persona. Optional for the §31.5 rollout reason.
-   */
-  title: z17.string().min(1).optional(),
-  description: z17.string().min(1).optional(),
-  platforms: z17.array(SocialPlatformSchema).optional(),
-  /**
-   * The built trees, one per deployable app, ordered as the declaration orders its apps. Empty for
-   * a data-only blueprint: it declares no app, builds nothing, and still ships a crew (ADR-0900).
-   */
-  trees: z17.array(BlueprintTreeSchema),
-  /**
-   * 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
-   * object at different times, so one component renders both.
-   */
-  questions: z17.array(QuestionFieldSchema),
-  schedules: z17.array(BlueprintScheduleSchema),
-  /** Who the crew is, and what it deploys — §31.5. Derived from `declaration`, never stored twice. */
-  agents: z17.array(BlueprintCrewSchema),
-  apps: z17.array(BlueprintAppSchema),
-  /**
-   * The agents a template creates per client the operator signs — printed, never provisioned by an
-   * apply (§31.1). Absent on rows published before WS12 v2, hence optional.
-   */
-  crew_per_client: z17.array(BlueprintCrewSchema).optional(),
-  /**
-   * The personas the crew posts from, and which accounts to connect to each before the crew
-   * exists (§31.10). Derived from `declaration` like `agents`; optional for the §31.5 rollout reason.
-   */
-  identities: z17.array(BlueprintIdentitySchema).optional(),
-  /**
-   * The creator template a row was published from (§42.8), `null` on every first-party row.
-   * `creator_name` is the public display name the landing page credits. The API sends all three
-   * on every row; they are optional here only so an artifact typed before §42 still reads.
-   */
-  creator_template_id: idOf("ctp").nullish(),
-  creator_template_version: z17.number().int().positive().nullish(),
-  creator_name: z17.string().min(1).nullish(),
-  published_at: Timestamp
-});
-
-// ../core/src/schema/vault.ts
-import { z as z18 } from "zod";
-var VaultCredentialKindSchema = z18.enum(["env_var", "static_bearer", "mcp_oauth"]);
-var VaultSchema = z18.object({
-  id: idOf("vlt"),
-  object: z18.literal("vault"),
-  identity_id: idOf("idn").nullable(),
-  display_name: z18.string().min(1).max(128),
-  credential_count: z18.number().int().nonnegative(),
-  created_at: Timestamp
-});
-var VaultCredentialSchema = z18.object({
-  id: idOf("vcr"),
-  object: z18.literal("vault_credential"),
-  vault_id: idOf("vlt"),
-  kind: VaultCredentialKindSchema,
-  /** For `env_var`, the environment variable name. For the MCP kinds, a display label. */
-  key: z18.string().min(1).max(128),
-  /** The exact destination host an `env_var` credential is bound to. Never a wildcard. */
-  host: z18.string().nullable(),
-  /** The exact MCP server URL an `mcp_*` token is matched to. */
-  mcp_server_url: z18.url().nullable(),
-  /**
-   * The one agent this credential may be injected into (ADR-1097). `null` is any agent that
-   * declares `mcp_server_url` — except the platform's own `/v1/mcp`, whose key is never injected
-   * unbound. Set at create, by `admin`, and immutable like the rest. Defaults to `null` so a
-   * client reading a control plane older than the field still parses the row.
-   */
-  agent_id: idOf("agt").nullable().default(null),
-  placeholder_ref: z18.string(),
-  expires_at: Timestamp.nullable(),
-  last_injected_at: Timestamp.nullable(),
-  created_at: Timestamp
-});
+import { z as z20 } from "zod";
 
-// ../core/src/schema/handoff.ts
+// ../core/src/schema/mini-app.ts
 import { z as z19 } from "zod";
-var MAX_HANDOFF_TARGETS = 6;
-var HandoffRequestSchema = z19.object({
-  agent: z19.string().min(1),
-  message: z19.string().min(1),
-  handoff_key: z19.string().min(1).max(128).optional(),
-  budget_micro_usd: z19.number().int().positive().optional()
-});
-var HandoffSchema = z19.object({
-  object: z19.literal("handoff"),
-  session_id: idOf("ses"),
-  status: z19.enum(["queued", "already_running"]),
-  handoff_key: z19.string().nullable()
-});
-var SessionHandoffRequestSchema = z19.object({
-  agents: z19.array(z19.string().min(1)).min(1).max(MAX_HANDOFF_TARGETS),
-  message: z19.string().min(1),
-  handoff_key: z19.string().min(1).max(128).optional(),
-  budget_micro_usd: z19.number().int().positive().optional()
-});
-var HandoffRefusalSchema = z19.object({
-  object: z19.literal("handoff_refusal"),
-  agent: z19.string(),
-  code: z19.string(),
-  message: z19.string()
-});
-var HandoffBatchSchema = z19.object({
-  object: z19.literal("handoff_batch"),
-  handoffs: z19.array(HandoffSchema.extend({ agent_id: idOf("agt") })),
-  refusals: z19.array(HandoffRefusalSchema)
-});
-var SessionHandoffSchema = z19.object({
-  from_session: idOf("ses"),
-  from_agent: idOf("agt"),
-  key: z19.string().nullable(),
-  depth: z19.number().int().positive()
-});
-var ChannelBriefSchema = z19.object({
-  root_session_id: idOf("ses"),
-  name: z19.string().min(1),
-  members: z19.array(z19.string().min(1)),
-  /**
-   * The receiver's own name, so it can tell the part of a post addressed to it from a teammate's
-   * (ADR-1099). Optional: a brief pinned before it existed still parses.
-   */
-  you: z19.string().min(1).optional()
-});
-var ChannelPostRequestSchema = z19.object({
-  message: z19.string().min(1).max(2e4)
-});
-var ChannelPostSchema = z19.object({
-  object: z19.literal("channel_post"),
-  root_session_id: idOf("ses"),
-  queued: z19.boolean()
-});
 
 // ../core/src/schema/show.ts
-import { z as z20 } from "zod";
+import { z as z17 } from "zod";
 var SHOW_SOURCES = ["spend_by_day", "post_views", "roadmap", "schedule"];
-var ShowSourceSchema = z20.enum(SHOW_SOURCES);
-var ShowArgsSchema = z20.object({
+var ShowSourceSchema = z17.enum(SHOW_SOURCES);
+var ShowArgsSchema = z17.object({
   source: ShowSourceSchema.describe(
     "What to show: spend_by_day (company spend per day, a line), post_views (views per recent post, bars), roadmap (the board's work by status), schedule (routines and scheduled posts over the next 7 days)."
   ),
-  days: z20.number().int().min(2).max(30).optional().describe("spend_by_day only: days back, today included. Default 14.")
+  days: z17.number().int().min(2).max(30).optional().describe("spend_by_day only: days back, today included. Default 14.")
 });
-var Day = z20.string().regex(/^\d{4}-\d{2}-\d{2}$/);
-var Count = z20.number().int().nonnegative();
-var head = { title: z20.string().min(1), as_of: Timestamp, timezone: z20.string().min(1) };
-var SpendByDayViewSchema = z20.object({
-  source: z20.literal("spend_by_day"),
+var Day = z17.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+var Count = z17.number().int().nonnegative();
+var head = { title: z17.string().min(1), as_of: Timestamp, timezone: z17.string().min(1) };
+var SpendByDayViewSchema = z17.object({
+  source: z17.literal("spend_by_day"),
   ...head,
-  days: z20.array(z20.object({ day: Day, micro_usd: Count })).min(2).max(30)
+  days: z17.array(z17.object({ day: Day, micro_usd: Count })).min(2).max(30)
 });
-var PostViewsViewSchema = z20.object({
-  source: z20.literal("post_views"),
+var PostViewsViewSchema = z17.object({
+  source: z17.literal("post_views"),
   ...head,
-  posts: z20.array(z20.object({ post_id: z20.string().min(1), label: z20.string(), networks: z20.array(z20.string()), posted_at: Timestamp, views: Count })).max(12)
+  posts: z17.array(z17.object({ post_id: z17.string().min(1), label: z17.string(), networks: z17.array(z17.string()), posted_at: Timestamp, views: Count })).max(12)
 });
-var RoadmapViewSchema = z20.object({
-  source: z20.literal("roadmap"),
+var RoadmapViewSchema = z17.object({
+  source: z17.literal("roadmap"),
   ...head,
-  groups: z20.array(
-    z20.object({
+  groups: z17.array(
+    z17.object({
       status: BoardStatusSchema,
       count: Count,
-      cards: z20.array(z20.object({ title: z20.string(), assignee: z20.string().nullable(), waits_on: z20.array(z20.string()) })).max(5)
+      cards: z17.array(z17.object({ title: z17.string(), assignee: z17.string().nullable(), waits_on: z17.array(z17.string()) })).max(5)
     })
   )
 });
-var ScheduleViewSchema = z20.object({
-  source: z20.literal("schedule"),
+var ScheduleViewSchema = z17.object({
+  source: z17.literal("schedule"),
   ...head,
-  days: z20.array(
-    z20.object({
+  days: z17.array(
+    z17.object({
       day: Day,
       count: Count,
-      items: z20.array(
-        z20.discriminatedUnion("kind", [
-          z20.object({ kind: z20.literal("routine"), at: Timestamp, agent: z20.string(), text: z20.string(), runs: z20.number().int().min(1).max(100) }),
-          z20.object({ kind: z20.literal("post"), at: Timestamp, networks: z20.array(z20.string()), text: z20.string() })
+      items: z17.array(
+        z17.discriminatedUnion("kind", [
+          z17.object({ kind: z17.literal("routine"), at: Timestamp, agent: z17.string(), text: z17.string(), runs: z17.number().int().min(1).max(100) }),
+          z17.object({ kind: z17.literal("post"), at: Timestamp, networks: z17.array(z17.string()), text: z17.string() })
         ])
       ).max(8)
     })
   ).max(7)
 });
-var ShowViewSchema = z20.discriminatedUnion("source", [
+var ShowViewSchema = z17.discriminatedUnion("source", [
   SpendByDayViewSchema,
   PostViewsViewSchema,
   RoadmapViewSchema,
   ScheduleViewSchema
 ]);
 
-// ../core/src/schema/compose.ts
-import { z as z22 } from "zod";
-
 // ../core/src/schema/catalog.ts
-import { z as z21 } from "zod";
-var Key = z21.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,39}$/, "an element key is a short name: a letter, then letters, digits, - or _");
-var Count2 = z21.number().int().nonnegative();
+import { z as z18 } from "zod";
+var Key = z18.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,39}$/, "an element key is a short name: a letter, then letters, digits, - or _");
+var Count2 = z18.number().int().nonnegative();
 var DIGIT = "words only: a digit is refused, because every number on the card is read by code from a $source binding";
-var words = (max) => z21.string().trim().min(1).max(max).regex(/^[^0-9]*$/, DIGIT).refine((text) => !new RegExp("\\p{N}", "u").test(text), DIGIT);
-var Days = z21.number().int().min(1).max(30).default(7).describe("The window: today and the days before it, on the company's clock. Default 7.");
+var words = (max) => z18.string().trim().min(1).max(max).regex(/^[^0-9]*$/, DIGIT).refine((text) => !new RegExp("\\p{N}", "u").test(text), DIGIT);
+var Days = z18.number().int().min(1).max(30).default(7).describe("The window: today and the days before it, on the company's clock. Default 7.");
 function bound(sources2, shape) {
   const example = JSON.stringify({ $source: sources2[0] });
-  return z21.strictObject(
-    { $source: z21.enum(sources2), ...shape },
+  return z18.strictObject(
+    { $source: z18.enum(sources2), ...shape },
     { error: (issue) => issue.code === "invalid_type" ? `must be a binding such as ${example}: a literal value is refused, code reads every number` : void 0 }
   );
 }
@@ -2177,38 +2044,38 @@ var Bound = {
   delta: bound(["views_change"], {}).describe(
     "views_change: the value's views_total against the same number of days before it, as a percentage. Its window is the value's."
   ),
-  series: bound(["spend_by_day"], { days: z21.number().int().min(2).max(30).default(14) }).describe("spend_by_day: the company's spend per day (the CEO only)."),
-  bars: bound(["post_views"], { limit: z21.number().int().min(1).max(12).default(5).describe("How many posts, newest first. Default 5.") }).describe(
+  series: bound(["spend_by_day"], { days: z18.number().int().min(2).max(30).default(14) }).describe("spend_by_day: the company's spend per day (the CEO only)."),
+  bars: bound(["post_views"], { limit: z18.number().int().min(1).max(12).default(5).describe("How many posts, newest first. Default 5.") }).describe(
     "post_views: each recent post's latest views, newest first."
   ),
-  progress: bound(["posts_this_week"], {}).describe("posts_this_week: posts published since Monday against the weekly cadence from the company's setup."),
+  progress: bound(["posts_this_week"], {}).describe("posts_this_week: posts published since Monday against the weekly cadence from the company's setup or its channel plan, else 3\xD7 a week."),
   board: bound(["roadmap"], {}).describe("roadmap: the board's work by status."),
   week: bound(["schedule"], {}).describe("schedule: routines and scheduled posts over the next 7 days."),
-  media: z21.union([bound(["latest_media"], { count: z21.number().int().min(1).max(4).default(1) }), z21.array(idOf("fil")).min(1).max(4)]).describe('{"$source":"latest_media","count":1} for the newest posted pictures or clips, or up to 4 fil_ ids.')
+  media: z18.union([bound(["latest_media"], { count: z18.number().int().min(1).max(4).default(1) }), z18.array(idOf("fil")).min(1).max(4)]).describe('{"$source":"latest_media","count":1} for the newest posted pictures or clips, or up to 4 fil_ ids.')
 };
-var SpendDay = z21.strictObject({ day: z21.string().regex(/^\d{4}-\d{2}-\d{2}$/), micro_usd: Count2 });
+var SpendDay = z18.strictObject({ day: z18.string().regex(/^\d{4}-\d{2}-\d{2}$/), micro_usd: Count2 });
 var Resolved = {
-  value: z21.discriminatedUnion("$source", [
-    z21.strictObject({ $source: z21.literal("views_total"), days: z21.number().int(), value: Count2, posts: Count2 }),
-    z21.strictObject({ $source: z21.literal("spend_total"), days: z21.number().int(), value: Count2 })
+  value: z18.discriminatedUnion("$source", [
+    z18.strictObject({ $source: z18.literal("views_total"), days: z18.number().int(), value: Count2, posts: Count2 }),
+    z18.strictObject({ $source: z18.literal("spend_total"), days: z18.number().int(), value: Count2 })
   ]),
-  delta: z21.strictObject({ $source: z21.literal("views_change"), days: z21.number().int(), current: Count2, previous: Count2 }),
-  series: z21.strictObject({ $source: z21.literal("spend_by_day"), days: z21.number().int(), points: z21.array(SpendDay).min(2).max(30) }),
-  bars: z21.strictObject({ $source: z21.literal("post_views"), limit: z21.number().int(), posts: PostViewsViewSchema.shape.posts }),
-  progress: z21.strictObject({ $source: z21.literal("posts_this_week"), value: Count2, max: z21.number().int().positive(), cadence: z21.string() }),
-  board: z21.strictObject({ $source: z21.literal("roadmap"), groups: RoadmapViewSchema.shape.groups }),
-  week: z21.strictObject({ $source: z21.literal("schedule"), days: ScheduleViewSchema.shape.days }),
-  media: z21.array(z21.strictObject({ id: idOf("fil"), kind: z21.enum(["image", "video"]) })).min(1).max(4)
+  delta: z18.strictObject({ $source: z18.literal("views_change"), days: z18.number().int(), current: Count2, previous: Count2 }),
+  series: z18.strictObject({ $source: z18.literal("spend_by_day"), days: z18.number().int(), points: z18.array(SpendDay).min(2).max(30) }),
+  bars: z18.strictObject({ $source: z18.literal("post_views"), limit: z18.number().int(), posts: PostViewsViewSchema.shape.posts }),
+  progress: z18.strictObject({ $source: z18.literal("posts_this_week"), value: Count2, max: z18.number().int().positive(), cadence: z18.string() }),
+  board: z18.strictObject({ $source: z18.literal("roadmap"), groups: RoadmapViewSchema.shape.groups }),
+  week: z18.strictObject({ $source: z18.literal("schedule"), days: ScheduleViewSchema.shape.days }),
+  media: z18.array(z18.strictObject({ id: idOf("fil"), kind: z18.enum(["image", "video"]) })).min(1).max(4)
 };
-var box = { children: z21.array(Key).min(1).max(12) };
-var leaf = { children: z21.array(Key).max(0).optional() };
+var box = { children: z18.array(Key).min(1).max(12) };
+var leaf = { children: z18.array(Key).max(0).optional() };
 var label = words(40).optional();
-var element = (type, props, children, about) => z21.strictObject({ type: z21.literal(type), props: z21.strictObject(props), ...children }).describe(about);
+var element = (type, props, children, about) => z18.strictObject({ type: z18.literal(type), props: z18.strictObject(props), ...children }).describe(about);
 function catalog(slot) {
   return {
     Card: element("Card", { title: words(60) }, box, "The card, with a short title. It is the root, and only the root."),
     Stack: element("Stack", {}, box, "Children one under another."),
-    Grid: element("Grid", { columns: z21.literal([1, 2, 3]) }, box, "Children side by side, 1 to 3 columns."),
+    Grid: element("Grid", { columns: z18.literal([1, 2, 3]) }, box, "Children side by side, 1 to 3 columns."),
     Metric: element("Metric", { label: words(40), value: slot.value, delta: slot.delta.optional() }, leaf, "One big number with a label, and optionally its change."),
     LineChart: element("LineChart", { label, series: slot.series }, leaf, "A line over days."),
     BarList: element("BarList", { label, bars: slot.bars }, leaf, "One bar per post."),
@@ -2244,14 +2111,374 @@ function tree(rootType, max, spec2, ctx) {
   const lost = keys.find((key) => !reached.has(key));
   if (lost) refuse2(`"${lost}" is not under the root`, ["elements", lost]);
 }
-var spec = (element2, rootType, max) => z21.strictObject({ root: Key, elements: z21.record(Key, element2) }).superRefine((value, ctx) => tree(rootType, max, value, ctx));
+var spec = (element2, rootType, max) => z18.strictObject({ root: Key, elements: z18.record(Key, element2) }).superRefine((value, ctx) => tree(rootType, max, value, ctx));
+
+// ../core/src/schema/mini-app.ts
+var PAGE_BLOCKS = [
+  "Page",
+  "Section",
+  "Stack",
+  "Grid",
+  "Metric",
+  "LineChart",
+  "BarList",
+  "Progress",
+  "Roadmap",
+  "Schedule",
+  "Media",
+  "Text",
+  "Needs",
+  "Activity",
+  "Accounts",
+  "Posts",
+  "Answers",
+  "MediaLibrary"
+];
+var MAX_PAGE_ELEMENTS = 48;
+var MINI_APP_ICONS = ["grid", "list", "chart", "calendar", "play"];
+var MiniAppIconSchema = z19.enum(MINI_APP_ICONS);
+var SLUG = "[a-z][a-z0-9-]{0,39}";
+var MiniAppSlugSchema = z19.string().regex(new RegExp(`^${SLUG}$`), "a slug is lowercase letters, digits and -");
+var Place = z19.string().regex(new RegExp(`^/(board|connections|apps/${SLUG}(\\?page=${SLUG})?)$`), "a section links to /board, /connections or /apps/<slug>[?page=<slug>]");
+var POSTS = ["waiting", "scheduled", "posted"];
+var PostStatus = z19.enum(POSTS);
+var PostLayout = z19.enum(["list", "row", "grid"]);
+var PostStatuses = z19.union([PostStatus, z19.array(PostStatus).min(1).max(3).refine((all) => new Set(all).size === all.length, "each status once")]);
+var PageBound = {
+  ...Bound,
+  board: bound(["roadmap"], { per_group: z19.number().int().min(1).max(5).default(5) }),
+  media: bound(["latest_media", "newest_media"], { count: z19.number().int().min(1).max(6).default(4) })
+};
+var PageResolved = {
+  ...Resolved,
+  board: z19.strictObject({ $source: z19.literal("roadmap"), per_group: z19.number().int(), groups: RoadmapViewSchema.shape.groups }),
+  media: z19.array(z19.strictObject({ id: z19.string(), kind: z19.enum(["image", "video"]) })).max(6)
+};
+function pageBlocks(slot) {
+  return {
+    Page: element("Page", {}, box, "The page itself, the root and only the root."),
+    Section: element("Section", { title: words(40), to: Place.optional(), hide_empty: z19.boolean().optional() }, box, "A titled part of the page; hidden when every block in it is empty, if asked."),
+    Needs: element("Needs", { label, needs: slot.needs }, leaf, "What waits on a person: approvals, questions, spent caps."),
+    Activity: element("Activity", { label, agents: slot.agents }, leaf, "The agents working or waiting, and on what."),
+    Accounts: element("Accounts", { accounts: slot.accounts }, leaf, "The template's networks: connected with a handle, or not."),
+    Posts: element(
+      "Posts",
+      { label, layout: PostLayout.optional(), posts: slot.posts },
+      leaf,
+      "Posts waiting on a person, scheduled, or posted; several statuses make one list. Drawn as rows (list, the default), one sideways row of cards (row), or a picture grid (grid)."
+    ),
+    Answers: element("Answers", { answers: slot.answers }, leaf, "The setup's answers in one line, linking to the setup."),
+    // No binding: the studio's gallery reads and pages the company's files itself (ADR-0987).
+    MediaLibrary: element("MediaLibrary", {}, leaf, "Every picture and clip the company's agents made, with filters, sort and a viewer.")
+  };
+}
+var OwnBound = pageBlocks({
+  needs: bound(["needs"], {}),
+  agents: bound(["agents_activity"], {}),
+  accounts: bound(["accounts"], {}),
+  posts: bound(["posts"], { status: PostStatuses, limit: z19.number().int().min(1).max(50).default(10) }),
+  answers: bound(["answers"], { keys: z19.array(Key).min(1).max(TEMPLATE_QUESTIONS_MAX) })
+});
+var Need = z19.object({
+  session_id: z19.string(),
+  agent_id: z19.string(),
+  agent: z19.string(),
+  since: Timestamp,
+  /** The chat's stored title, or `null`: the studio names it by when it began. */
+  title: z19.string().nullable(),
+  kind: z19.enum(["tool", "question", "budget"]),
+  /** The call or question it is held on; `null` for a spent cap. */
+  action: PendingActionSchema.nullable()
+});
+var Working = z19.object({
+  agent_id: z19.string(),
+  agent: z19.string(),
+  state: z19.enum(["working", "waiting"]),
+  session_id: z19.string().nullable(),
+  title: z19.string().nullable(),
+  at: Timestamp
+});
+var OwnResolved = pageBlocks({
+  needs: z19.strictObject({ $source: z19.literal("needs"), items: z19.array(Need) }),
+  agents: z19.strictObject({ $source: z19.literal("agents_activity"), agents: z19.array(Working) }),
+  accounts: z19.strictObject({
+    $source: z19.literal("accounts"),
+    accounts: z19.array(z19.object({ platform: SocialPlatformSchema, connected: z19.boolean(), handle: z19.string().nullable() }))
+  }),
+  posts: z19.strictObject({ $source: z19.literal("posts"), status: z19.union([PostStatus, z19.array(PostStatus)]), limit: z19.number().int(), posts: z19.array(PostSchema), more: z19.boolean() }),
+  answers: z19.strictObject({
+    $source: z19.literal("answers"),
+    keys: z19.array(z19.string()),
+    values: z19.array(z19.string()),
+    template: z19.object({ blueprint: z19.string(), template: z19.string() }).nullable()
+  })
+});
+var BoundBlocks = { ...catalog(PageBound), ...OwnBound };
+var ResolvedBlocks = { ...catalog(PageResolved), ...OwnResolved };
+var Unread = element("Unread", { of: z19.string(), label: z19.string().nullable(), reason: z19.string() }, leaf, "A block that could not be read.");
+var B = BoundBlocks;
+var PageSpecSchema = spec(
+  z19.discriminatedUnion(
+    "type",
+    [B.Page, B.Section, B.Stack, B.Grid, B.Metric, B.LineChart, B.BarList, B.Progress, B.Roadmap, B.Schedule, B.Media, B.Text, B.Needs, B.Activity, B.Accounts, B.Posts, B.Answers, B.MediaLibrary],
+    unknownComponent(PAGE_BLOCKS)
+  ),
+  "Page",
+  MAX_PAGE_ELEMENTS
+);
+var R = ResolvedBlocks;
+var ResolvedPageElementSchema = z19.discriminatedUnion(
+  "type",
+  [R.Page, R.Section, R.Stack, R.Grid, R.Metric, R.LineChart, R.BarList, R.Progress, R.Roadmap, R.Schedule, R.Media, R.Text, R.Needs, R.Activity, R.Accounts, R.Posts, R.Answers, R.MediaLibrary, Unread],
+  unknownComponent(PAGE_BLOCKS)
+);
+var ResolvedPageSpecSchema = spec(ResolvedPageElementSchema, "Page", MAX_PAGE_ELEMENTS);
+var unique = (items) => new Set(items.map((item) => item.slug)).size === items.length;
+var MiniAppPageSchema = z19.strictObject({ slug: MiniAppSlugSchema, title: words(24), spec: PageSpecSchema });
+var MiniAppDeclSchema = z19.strictObject({
+  slug: MiniAppSlugSchema,
+  name: words(40),
+  icon: MiniAppIconSchema,
+  pages: z19.array(MiniAppPageSchema).min(1).max(6).refine(unique, "each page's slug is its own")
+});
+var MiniAppDeclsSchema = z19.array(MiniAppDeclSchema).max(8).refine(unique, "each mini app's slug is its own");
+var MiniAppSummarySchema = z19.object({
+  object: z19.literal("mini_app"),
+  slug: MiniAppSlugSchema,
+  name: z19.string(),
+  icon: MiniAppIconSchema,
+  pages: z19.array(z19.object({ slug: MiniAppSlugSchema, title: z19.string() })).min(1),
+  /** What it reads (`miniAppReads`). Absent from an older API: the Studio then claims nothing it cannot see. */
+  reads: z19.array(z19.string()).optional()
+});
+var MiniAppSchema = MiniAppSummarySchema.extend({
+  networks: z19.array(z19.object({ platform: SocialPlatformSchema, connected: z19.boolean().nullable() })),
+  page: MiniAppSlugSchema,
+  as_of: Timestamp,
+  timezone: z19.string().min(1),
+  spec: ResolvedPageSpecSchema
+});
+
+// ../core/src/schema/blueprint.ts
+var BlueprintScheduleSchema = z20.object({
+  agent: z20.string().min(1),
+  cron: z20.string().min(1),
+  timezone: z20.string().nullable(),
+  /** The message each fire opens its session with — the sentence worth printing. */
+  input: z20.string().min(1),
+  /** What a fire does in a few words, as the template says it (ADR-1172); absent on a row that declares none. */
+  summary: z20.string().min(1).optional(),
+  budget_micro_usd: MicroUsdField.nonnegative()
+});
+var BlueprintBudgetSchema = BlueprintScheduleSchema.pick({ agent: true, cron: true, budget_micro_usd: true });
+var BlueprintCrewSchema = z20.object({
+  name: z20.string().min(1),
+  description: z20.string().nullable(),
+  model: z20.string().min(1),
+  briefed: z20.boolean(),
+  intake: z20.string().nullable().optional(),
+  /** What the first session may spend: the intake's own cap, else the agent's (§31.4). Set iff `briefed`. */
+  intake_micro_usd: MicroUsdField.nonnegative().optional(),
+  role: z20.string().min(1).optional(),
+  skills: z20.array(SkillRefSchema).optional(),
+  tools: z20.array(z20.string().min(1)).optional(),
+  required: z20.boolean().optional()
+});
+var BlueprintAppSchema = z20.object({
+  name: z20.string().min(1),
+  type: AppTypeSchema,
+  description: z20.string().nullable(),
+  mcp: z20.string().nullable().optional(),
+  tools: z20.array(z20.string().min(1)).optional(),
+  /** Whether an install may deselect it (§31.2). Optional: the rollout argument above. */
+  required: z20.boolean().optional()
+});
+var BlueprintIdentitySchema = z20.object({
+  name: z20.string().min(1),
+  description: z20.string().nullable()
+});
+var ContentHashSchema = z20.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
+var BlueprintTaskSchema = z20.object({ title: z20.string().min(1), assignee: z20.string().min(1).nullable() });
+var BlueprintMiniAppSchema = z20.object({ slug: MiniAppSlugSchema, name: z20.string().min(1), icon: MiniAppIconSchema });
+var BlueprintTreeSchema = z20.object({
+  /** `apps[].name` in the declaration — the same name §31.5 prints and the install ensures by. */
+  app: z20.string().min(1),
+  content_hash: ContentHashSchema
+});
+var BlueprintArtifactSchema = z20.object({
+  id: idOf("bpa"),
+  object: z20.literal("blueprint_artifact"),
+  /** The machine — its repository, screens and `/api/*`. */
+  blueprint: z20.string().min(1),
+  /** Which of that blueprint's templates provides the crew. */
+  template: z20.string().min(1),
+  /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
+  version: z20.string().min(1),
+  /**
+   * What a person calls the template, one line on what its crew does, and the networks it publishes
+   * to — printed, never provisioned (§31.5, ADR-0921). `platforms` is decoration: where the crew
+   * posts is the accounts connected to its persona. Optional for the §31.5 rollout reason.
+   */
+  title: z20.string().min(1).optional(),
+  description: z20.string().min(1).optional(),
+  platforms: z20.array(SocialPlatformSchema).optional(),
+  /**
+   * The built trees, one per deployable app, ordered as the declaration orders its apps. Empty for
+   * a data-only blueprint: it declares no app, builds nothing, and still ships a crew (ADR-0900).
+   */
+  trees: z20.array(BlueprintTreeSchema),
+  /**
+   * 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
+   * object at different times, so one component renders both.
+   */
+  questions: z20.array(QuestionFieldSchema),
+  schedules: z20.array(BlueprintScheduleSchema),
+  /** Who the crew is, and what it deploys — §31.5. Derived from `declaration`, never stored twice. */
+  agents: z20.array(BlueprintCrewSchema),
+  apps: z20.array(BlueprintAppSchema),
+  /**
+   * The agents a template creates per client the operator signs — printed, never provisioned by an
+   * apply (§31.1). Absent on rows published before WS12 v2, hence optional.
+   */
+  crew_per_client: z20.array(BlueprintCrewSchema).optional(),
+  /**
+   * The personas the crew posts from, and which accounts to connect to each before the crew
+   * exists (§31.10). Derived from `declaration` like `agents`; optional for the §31.5 rollout reason.
+   */
+  identities: z20.array(BlueprintIdentitySchema).optional(),
+  /**
+   * The crew's first work: the cards an apply seeds on the board (§31.11), as a title and who has
+   * it, in the declared order. Derived from `declaration` like `agents`, so a person reads day one
+   * before paying for it (the launch roadmap, ADR-1170); optional for the §31.5 rollout reason.
+   */
+  tasks: z20.array(BlueprintTaskSchema).optional(),
+  /**
+   * The mini apps the template brings (§50.1): no tree, no deploy, so they are not in `apps`, and a
+   * person is shown them beside the hosted ones before paying (ADR-1171). Derived from
+   * `declaration.mini_apps` like `tasks`; optional for the §31.5 rollout reason.
+   */
+  mini_apps: z20.array(BlueprintMiniAppSchema).optional(),
+  /** The first week in the template's own words (ADR-1172): Day 1, what each day after it carries, and what follows the week. */
+  roadmap: z20.object({ day_one: z20.string().min(1).optional(), every_day: z20.string().min(1).optional(), after: z20.string().min(1).optional() }).optional(),
+  /**
+   * The creator template a row was published from (§42.8), `null` on every first-party row.
+   * `creator_name` is the public display name the landing page credits. The API sends all three
+   * on every row; they are optional here only so an artifact typed before §42 still reads.
+   */
+  creator_template_id: idOf("ctp").nullish(),
+  creator_template_version: z20.number().int().positive().nullish(),
+  creator_name: z20.string().min(1).nullish(),
+  /**
+   * The listing a reviewer curated for a creator row (§42.8): its one-line pitch, and a public
+   * sample video with its poster frame. Optional and nullish — a first-party row and a row whose
+   * listing names no hero carry none, and the landing page prints only what is present.
+   */
+  creator_tagline: z20.string().min(1).nullish(),
+  creator_hero_url: z20.string().url().nullish(),
+  creator_hero_poster_url: z20.string().url().nullish(),
+  published_at: Timestamp
+});
+
+// ../core/src/schema/vault.ts
+import { z as z21 } from "zod";
+var VaultCredentialKindSchema = z21.enum(["env_var", "static_bearer", "mcp_oauth"]);
+var VaultSchema = z21.object({
+  id: idOf("vlt"),
+  object: z21.literal("vault"),
+  identity_id: idOf("idn").nullable(),
+  display_name: z21.string().min(1).max(128),
+  credential_count: z21.number().int().nonnegative(),
+  created_at: Timestamp
+});
+var VaultCredentialSchema = z21.object({
+  id: idOf("vcr"),
+  object: z21.literal("vault_credential"),
+  vault_id: idOf("vlt"),
+  kind: VaultCredentialKindSchema,
+  /** For `env_var`, the environment variable name. For the MCP kinds, a display label. */
+  key: z21.string().min(1).max(128),
+  /** The exact destination host an `env_var` credential is bound to. Never a wildcard. */
+  host: z21.string().nullable(),
+  /** The exact MCP server URL an `mcp_*` token is matched to. */
+  mcp_server_url: z21.url().nullable(),
+  /**
+   * The one agent this credential may be injected into (ADR-1097). `null` is any agent that
+   * declares `mcp_server_url` — except the platform's own `/v1/mcp`, whose key is never injected
+   * unbound. Set at create, by `admin`, and immutable like the rest. Defaults to `null` so a
+   * client reading a control plane older than the field still parses the row.
+   */
+  agent_id: idOf("agt").nullable().default(null),
+  placeholder_ref: z21.string(),
+  expires_at: Timestamp.nullable(),
+  last_injected_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+
+// ../core/src/schema/handoff.ts
+import { z as z22 } from "zod";
+var MAX_HANDOFF_TARGETS = 6;
+var HandoffRequestSchema = z22.object({
+  agent: z22.string().min(1),
+  message: z22.string().min(1),
+  handoff_key: z22.string().min(1).max(128).optional(),
+  budget_micro_usd: z22.number().int().positive().optional()
+});
+var HandoffSchema = z22.object({
+  object: z22.literal("handoff"),
+  session_id: idOf("ses"),
+  status: z22.enum(["queued", "already_running"]),
+  handoff_key: z22.string().nullable()
+});
+var SessionHandoffRequestSchema = z22.object({
+  agents: z22.array(z22.string().min(1)).min(1).max(MAX_HANDOFF_TARGETS),
+  message: z22.string().min(1),
+  handoff_key: z22.string().min(1).max(128).optional(),
+  budget_micro_usd: z22.number().int().positive().optional()
+});
+var HandoffRefusalSchema = z22.object({
+  object: z22.literal("handoff_refusal"),
+  agent: z22.string(),
+  code: z22.string(),
+  message: z22.string()
+});
+var HandoffBatchSchema = z22.object({
+  object: z22.literal("handoff_batch"),
+  handoffs: z22.array(HandoffSchema.extend({ agent_id: idOf("agt") })),
+  refusals: z22.array(HandoffRefusalSchema)
+});
+var SessionHandoffSchema = z22.object({
+  from_session: idOf("ses"),
+  from_agent: idOf("agt"),
+  key: z22.string().nullable(),
+  depth: z22.number().int().positive()
+});
+var ChannelBriefSchema = z22.object({
+  root_session_id: idOf("ses"),
+  name: z22.string().min(1),
+  members: z22.array(z22.string().min(1)),
+  /**
+   * The receiver's own name, so it can tell the part of a post addressed to it from a teammate's
+   * (ADR-1099). Optional: a brief pinned before it existed still parses.
+   */
+  you: z22.string().min(1).optional()
+});
+var ChannelPostRequestSchema = z22.object({
+  message: z22.string().min(1).max(2e4)
+});
+var ChannelPostSchema = z22.object({
+  object: z22.literal("channel_post"),
+  root_session_id: idOf("ses"),
+  queued: z22.boolean()
+});
 
 // ../core/src/schema/compose.ts
+import { z as z23 } from "zod";
 var COMPOSE_COMPONENTS = ["Card", "Stack", "Grid", "Metric", "LineChart", "BarList", "Progress", "Roadmap", "Schedule", "Media", "Text"];
 var MAX_COMPOSE_ELEMENTS = 24;
 var BoundComponents = catalog(Bound);
 var ComposeSpecSchema = spec(
-  z22.discriminatedUnion(
+  z23.discriminatedUnion(
     "type",
     [
       BoundComponents.Card,
@@ -2271,14 +2498,14 @@ var ComposeSpecSchema = spec(
   "Card",
   MAX_COMPOSE_ELEMENTS
 );
-var ComposeArgsSchema = z22.object({
+var ComposeArgsSchema = z23.object({
   spec: ComposeSpecSchema.describe(
     'A json-render spec: { "root": key, "elements": { key: { "type", "props", "children"? } } }. The root is one Card.'
   )
 });
 var ComposedComponents = catalog(Resolved);
 var ComposedSpecSchema = spec(
-  z22.discriminatedUnion(
+  z23.discriminatedUnion(
     "type",
     [
       ComposedComponents.Card,
@@ -2298,39 +2525,39 @@ var ComposedSpecSchema = spec(
   "Card",
   MAX_COMPOSE_ELEMENTS
 );
-var ComposedSchema = z22.object({ as_of: Timestamp, timezone: z22.string().min(1), spec: ComposedSpecSchema });
+var ComposedSchema = z23.object({ as_of: Timestamp, timezone: z23.string().min(1), spec: ComposedSpecSchema });
 
 // ../core/src/schema/media.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var MEDIA_JOB_KINDS = ["video", "clip", "transcription"];
-var MediaJobKindSchema = z23.enum(MEDIA_JOB_KINDS);
-var MediaJobStatusSchema = z23.enum(["queued", "processing", "completed", "failed"]);
-var PublicUrl = z23.string().url().startsWith("http");
-var Score = z23.number().int().min(0).max(100);
-var Seconds = z23.number().nonnegative();
-var VideoResultSchema = z23.object({
-  files: z23.array(
-    z23.object({
+var MediaJobKindSchema = z24.enum(MEDIA_JOB_KINDS);
+var MediaJobStatusSchema = z24.enum(["queued", "processing", "completed", "failed"]);
+var PublicUrl = z24.string().url().startsWith("http");
+var Score = z24.number().int().min(0).max(100);
+var Seconds = z24.number().nonnegative();
+var VideoResultSchema = z24.object({
+  files: z24.array(
+    z24.object({
       file_id: idOf("fil"),
-      content_type: z23.string(),
-      width: z23.number().int().positive().nullable(),
-      height: z23.number().int().positive().nullable(),
+      content_type: z24.string(),
+      width: z24.number().int().positive().nullable(),
+      height: z24.number().int().positive().nullable(),
       duration_seconds: Seconds.nullable()
     })
   )
 });
-var ViralityScoreSchema = z23.object({
+var ViralityScoreSchema = z24.object({
   total: Score,
   shareability: Score,
   hook_strength: Score,
   story_quality: Score,
   emotional_impact: Score
 });
-var ClipResultSchema = z23.object({
-  clips: z23.array(
-    z23.object({
+var ClipResultSchema = z24.object({
+  clips: z24.array(
+    z24.object({
       file_id: idOf("fil"),
-      title: z23.string(),
+      title: z24.string(),
       start_seconds: Seconds,
       end_seconds: Seconds,
       duration_seconds: Seconds,
@@ -2338,192 +2565,192 @@ var ClipResultSchema = z23.object({
     })
   )
 });
-var TranscriptSchema = z23.object({
-  text: z23.string(),
-  language: z23.string().nullable(),
+var TranscriptSchema = z24.object({
+  text: z24.string(),
+  language: z24.string().nullable(),
   duration_seconds: Seconds.nullable(),
-  segments: z23.array(z23.object({ start_seconds: Seconds, end_seconds: Seconds, text: z23.string() }))
+  segments: z24.array(z24.object({ start_seconds: Seconds, end_seconds: Seconds, text: z24.string() }))
 });
-var MediaJobResultSchema = z23.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
-var MediaJobSchema = z23.object({
+var MediaJobResultSchema = z24.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
+var MediaJobSchema = z24.object({
   id: idOf("med"),
-  object: z23.literal("media_job"),
+  object: z24.literal("media_job"),
   kind: MediaJobKindSchema,
   status: MediaJobStatusSchema,
-  model: z23.string().nullable(),
-  input: z23.record(z23.string(), z23.unknown()),
+  model: z24.string().nullable(),
+  input: z24.record(z24.string(), z24.unknown()),
   result: MediaJobResultSchema.nullable(),
-  error: z23.object({ code: z23.string(), message: z23.string() }).nullable(),
+  error: z24.object({ code: z24.string(), message: z24.string() }).nullable(),
   cost_micro_usd: MicroUsdField.nullable(),
   session_id: idOf("ses").nullable(),
   created_at: Timestamp,
   completed_at: Timestamp.nullable()
 });
-var ImageRequestSchema = z23.object({
-  model: z23.string().min(1).optional(),
-  prompt: z23.string().min(1),
-  image_urls: z23.array(PublicUrl).max(4).optional(),
-  aspect_ratio: z23.string().optional(),
-  seed: z23.number().int().optional(),
-  n: z23.number().int().min(1).max(4).default(1)
+var ImageRequestSchema = z24.object({
+  model: z24.string().min(1).optional(),
+  prompt: z24.string().min(1),
+  image_urls: z24.array(PublicUrl).max(4).optional(),
+  aspect_ratio: z24.string().optional(),
+  seed: z24.number().int().optional(),
+  n: z24.number().int().min(1).max(4).default(1)
 });
-var VideoRequestSchema = z23.object({
+var VideoRequestSchema = z24.object({
   /** Omitted: the platform's video default while the catalogue publishes it (`resolveModel`, §33.2). */
-  model: z23.string().min(1).optional(),
-  prompt: z23.string().min(1),
-  image_urls: z23.array(PublicUrl).max(1).optional(),
+  model: z24.string().min(1).optional(),
+  prompt: z24.string().min(1),
+  image_urls: z24.array(PublicUrl).max(1).optional(),
   /** The source clip of a video-to-video edit (ADR-0814). */
   video_url: PublicUrl.optional(),
-  aspect_ratio: z23.string().optional(),
-  seed: z23.number().int().optional(),
-  seconds: z23.number().int().min(1).max(60).optional()
-});
-var ImageGenerationSchema = z23.object({
-  object: z23.literal("image_generation"),
-  model: z23.string(),
-  files: z23.array(FileSchema),
+  aspect_ratio: z24.string().optional(),
+  seed: z24.number().int().optional(),
+  seconds: z24.number().int().min(1).max(60).optional()
+});
+var ImageGenerationSchema = z24.object({
+  object: z24.literal("image_generation"),
+  model: z24.string(),
+  files: z24.array(FileSchema),
   cost_micro_usd: MicroUsdField
 });
-var ClipLength = z23.number().int().min(5).max(180);
-var ClipRequestSchema = z23.object({
+var ClipLength = z24.number().int().min(5).max(180);
+var ClipRequestSchema = z24.object({
   video_url: PublicUrl,
-  aspect_ratio: z23.enum(["9:16", "16:9"]).default("9:16"),
-  remove_silence: z23.boolean().default(false),
-  caption_preset: z23.enum(["none", "clean", "bold", "karaoke"]).default("none"),
-  language: z23.string().min(2).optional(),
+  aspect_ratio: z24.enum(["9:16", "16:9"]).default("9:16"),
+  remove_silence: z24.boolean().default(false),
+  caption_preset: z24.enum(["none", "clean", "bold", "karaoke"]).default("none"),
+  language: z24.string().min(2).optional(),
   min_seconds: ClipLength.default(15),
   max_seconds: ClipLength.default(60),
-  title: z23.string().min(1).optional()
+  title: z24.string().min(1).optional()
 });
-var AudioFormatSchema = z23.enum(["mp3", "wav", "ogg"]);
-var TranscriptionRequestSchema = z23.object({
-  model: z23.string().min(1).optional(),
+var AudioFormatSchema = z24.enum(["mp3", "wav", "ogg"]);
+var TranscriptionRequestSchema = z24.object({
+  model: z24.string().min(1).optional(),
   file_id: idOf("fil").optional(),
   url: PublicUrl.optional(),
-  language: z23.string().min(2).optional(),
-  timestamps: z23.boolean().default(true)
+  language: z24.string().min(2).optional(),
+  timestamps: z24.boolean().default(true)
 }).refine((request) => request.file_id === void 0 !== (request.url === void 0), {
   error: "exactly one of file_id or url",
   path: ["file_id"]
 });
-var SpeechRequestSchema = z23.object({
-  model: z23.string().min(1).optional(),
-  text: z23.string().min(1).max(4096),
-  voice: z23.string().min(1).optional(),
+var SpeechRequestSchema = z24.object({
+  model: z24.string().min(1).optional(),
+  text: z24.string().min(1).max(4096),
+  voice: z24.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3"),
-  speed: z23.number().min(0.5).max(2).optional()
+  speed: z24.number().min(0.5).max(2).optional()
 });
-var SpeechToSpeechRequestSchema = z23.object({
-  model: z23.string().min(1).optional(),
+var SpeechToSpeechRequestSchema = z24.object({
+  model: z24.string().min(1).optional(),
   file_id: idOf("fil"),
-  voice: z23.string().min(1).optional(),
+  voice: z24.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3")
 });
-var SpeechGenerationSchema = z23.object({
-  object: z23.literal("speech_generation"),
-  model: z23.string(),
+var SpeechGenerationSchema = z24.object({
+  object: z24.literal("speech_generation"),
+  model: z24.string(),
   file: FileSchema,
   duration_seconds: Seconds.nullable(),
   cost_micro_usd: MicroUsdField
 });
 
 // ../core/src/schema/app-data.ts
-import { z as z24 } from "zod";
-var DbTableSchema = z24.object({
-  object: z24.literal("db_table"),
-  name: z24.string(),
-  schema: z24.string().default("public"),
-  rows: z24.number().int().nonnegative().nullable(),
-  size_bytes: z24.number().int().nonnegative().nullable()
-});
-var DbMigrationSchema = z24.object({
+import { z as z25 } from "zod";
+var DbTableSchema = z25.object({
+  object: z25.literal("db_table"),
+  name: z25.string(),
+  schema: z25.string().default("public"),
+  rows: z25.number().int().nonnegative().nullable(),
+  size_bytes: z25.number().int().nonnegative().nullable()
+});
+var DbMigrationSchema = z25.object({
   id: idOf("dbm"),
-  object: z24.literal("db_migration"),
-  name: z24.string(),
-  sha256: z24.string().regex(/^[0-9a-f]{64}$/),
+  object: z25.literal("db_migration"),
+  name: z25.string(),
+  sha256: z25.string().regex(/^[0-9a-f]{64}$/),
   applied_at: Timestamp,
-  statements: z24.number().int().nonnegative()
+  statements: z25.number().int().nonnegative()
 });
-var ApplyDbMigrationSchema = z24.object({
-  name: z24.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
-  sql: z24.string().min(1)
+var ApplyDbMigrationSchema = z25.object({
+  name: z25.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
+  sql: z25.string().min(1)
 });
 var DB_REST_METHODS = ["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD"];
-var DbRestMethodSchema = z24.enum(DB_REST_METHODS);
+var DbRestMethodSchema = z25.enum(DB_REST_METHODS);
 var BUCKET_NAME = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
-var BucketSchema = z24.object({
-  object: z24.literal("bucket"),
-  name: z24.string().regex(BUCKET_NAME),
-  public: z24.boolean(),
+var BucketSchema = z25.object({
+  object: z25.literal("bucket"),
+  name: z25.string().regex(BUCKET_NAME),
+  public: z25.boolean(),
   created_at: Timestamp
 });
-var CreateBucketSchema = z24.object({
-  name: z24.string().regex(BUCKET_NAME, { error: "3\u201363 lowercase letters, digits and hyphens" }),
-  public: z24.boolean().default(false)
-});
-var StorageObjectSchema = z24.object({
-  object: z24.literal("storage_object"),
-  bucket: z24.string(),
-  key: z24.string().min(1),
-  size_bytes: z24.number().int().nonnegative(),
-  content_type: z24.string(),
-  etag: z24.string().nullable(),
+var CreateBucketSchema = z25.object({
+  name: z25.string().regex(BUCKET_NAME, { error: "3\u201363 lowercase letters, digits and hyphens" }),
+  public: z25.boolean().default(false)
+});
+var StorageObjectSchema = z25.object({
+  object: z25.literal("storage_object"),
+  bucket: z25.string(),
+  key: z25.string().min(1),
+  size_bytes: z25.number().int().nonnegative(),
+  content_type: z25.string(),
+  etag: z25.string().nullable(),
   updated_at: Timestamp
 });
-var SignedUrlMethodSchema = z24.enum(["PUT", "GET"]);
-var SignedUrlSchema = z24.object({
-  object: z24.literal("signed_url"),
-  url: z24.string().url(),
+var SignedUrlMethodSchema = z25.enum(["PUT", "GET"]);
+var SignedUrlSchema = z25.object({
+  object: z25.literal("signed_url"),
+  url: z25.string().url(),
   method: SignedUrlMethodSchema,
   expires_at: Timestamp
 });
-var CreateUploadUrlSchema = z24.object({
-  content_type: z24.string().min(1),
-  expires_seconds: z24.number().int().min(60).max(3600).default(900)
+var CreateUploadUrlSchema = z25.object({
+  content_type: z25.string().min(1),
+  expires_seconds: z25.number().int().min(60).max(3600).default(900)
 });
 
 // ../core/src/schema/stock-photo.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var STOCK_PHOTO_ORIENTATIONS = ["landscape", "portrait", "square"];
 var STOCK_PHOTO_SIZES = ["small", "medium", "large"];
-var StockPhotoQuerySchema = z25.object({
-  query: z25.string().min(1).max(200),
-  count: z25.coerce.number().int().min(1).max(30).default(10),
-  orientation: z25.enum(STOCK_PHOTO_ORIENTATIONS).optional(),
-  color: z25.string().min(1).max(32).optional(),
-  size: z25.enum(STOCK_PHOTO_SIZES).optional()
-});
-var StockPhotoSchema = z25.object({
-  object: z25.literal("stock_photo"),
-  id: z25.string().min(1),
-  width: z25.number().int().positive(),
-  height: z25.number().int().positive(),
-  url: z25.string().url(),
-  preview_url: z25.string().url(),
-  alt: z25.string().nullable(),
-  photographer: z25.string().nullable(),
-  attribution_url: z25.string().url().nullable(),
-  dominant_color: z25.string().nullable()
+var StockPhotoQuerySchema = z26.object({
+  query: z26.string().min(1).max(200),
+  count: z26.coerce.number().int().min(1).max(30).default(10),
+  orientation: z26.enum(STOCK_PHOTO_ORIENTATIONS).optional(),
+  color: z26.string().min(1).max(32).optional(),
+  size: z26.enum(STOCK_PHOTO_SIZES).optional()
+});
+var StockPhotoSchema = z26.object({
+  object: z26.literal("stock_photo"),
+  id: z26.string().min(1),
+  width: z26.number().int().positive(),
+  height: z26.number().int().positive(),
+  url: z26.string().url(),
+  preview_url: z26.string().url(),
+  alt: z26.string().nullable(),
+  photographer: z26.string().nullable(),
+  attribution_url: z26.string().url().nullable(),
+  dominant_color: z26.string().nullable()
 });
 
 // ../core/src/schema/creator.ts
-import { z as z26 } from "zod";
-var CreatorCodeSchema = z26.string().regex(/^[a-z0-9]{3,24}$/, "3 to 24 lowercase letters or digits");
-var PayoutMethodSchema = z26.enum(["wise", "paypal"]);
-var PayoutDetailsSchema = z26.object({
+import { z as z27 } from "zod";
+var CreatorCodeSchema = z27.string().regex(/^[a-z0-9]{3,24}$/, "3 to 24 lowercase letters or digits");
+var PayoutMethodSchema = z27.enum(["wise", "paypal"]);
+var PayoutDetailsSchema = z27.object({
   method: PayoutMethodSchema,
-  account: z26.string().min(1).max(320)
+  account: z27.string().min(1).max(320)
 });
-var CreatorStatusSchema = z26.enum(["active", "suspended"]);
-var CreatorSchema = z26.object({
+var CreatorStatusSchema = z27.enum(["active", "suspended"]);
+var CreatorSchema = z27.object({
   id: idOf("crt"),
-  object: z26.literal("creator"),
-  email: z26.email(),
-  display_name: z26.string().min(1).max(80),
+  object: z27.literal("creator"),
+  email: z27.email(),
+  display_name: z27.string().min(1).max(80),
   code: CreatorCodeSchema,
   status: CreatorStatusSchema,
   payout: PayoutDetailsSchema.nullable(),
-  clicks: z26.number().int().nonnegative(),
+  clicks: z27.number().int().nonnegative(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -2531,45 +2758,47 @@ var IdentityCreatorSchema = CreatorSchema.pick({
   id: true,
   status: true
 });
-var CreatorApplicationStatusSchema = z26.enum([
+var CreatorApplicationStatusSchema = z27.enum([
   "pending",
   "approved",
   "rejected"
 ]);
-var CreatorApplicationSchema = z26.object({
+var CreatorApplicationSchema = z27.object({
   id: idOf("cra"),
-  object: z26.literal("creator_application"),
-  email: z26.email(),
-  display_name: z26.string().min(1).max(80),
-  pitch: z26.string().min(1).max(2e3),
-  links: z26.array(z26.url({ protocol: /^https$/ })).max(5),
+  object: z27.literal("creator_application"),
+  email: z27.email(),
+  display_name: z27.string().min(1).max(80),
+  pitch: z27.string().min(1).max(2e3),
+  links: z27.array(z27.url({ protocol: /^https$/ })).max(5),
   status: CreatorApplicationStatusSchema,
-  note: z26.string().nullable(),
+  note: z27.string().nullable(),
   creator_id: idOf("crt").nullable(),
   created_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var ReferralStatusSchema = z26.enum(["pending", "active", "expired"]);
-var ReferralSchema = z26.object({
+var ReferralStatusSchema = z27.enum(["pending", "active", "expired"]);
+var ReferralSchema = z27.object({
   id: idOf("crf"),
-  object: z26.literal("referral"),
+  object: z27.literal("referral"),
   creator_id: idOf("crt"),
   organization_id: idOf("org"),
   status: ReferralStatusSchema,
   attributed_at: Timestamp,
   first_paid_at: Timestamp.nullable(),
-  commission_until: Timestamp.nullable()
+  commission_until: Timestamp.nullable(),
+  /** Opaque per-creator hash of the referred person, so organizations group by person; never the email. */
+  person_key: z27.string().nullable().optional()
 });
-var CommissionKindSchema = z26.enum(["referral", "template"]);
-var CommissionStatusSchema = z26.enum([
+var CommissionKindSchema = z27.enum(["referral", "template"]);
+var CommissionStatusSchema = z27.enum([
   "pending",
   "available",
   "claimed",
   "paid"
 ]);
-var CommissionSchema = z26.object({
+var CommissionSchema = z27.object({
   id: idOf("crc"),
-  object: z26.literal("commission"),
+  object: z27.literal("commission"),
   creator_id: idOf("crt"),
   kind: CommissionKindSchema,
   referral_id: idOf("crf").nullable(),
@@ -2582,123 +2811,290 @@ var CommissionSchema = z26.object({
   available_at: Timestamp,
   payout_id: idOf("crp").nullable()
 });
-var PayoutStatusSchema = z26.enum(["requested", "paid", "rejected"]);
-var PayoutSchema = z26.object({
+var PayoutStatusSchema = z27.enum(["requested", "paid", "rejected"]);
+var PayoutSchema = z27.object({
   id: idOf("crp"),
-  object: z26.literal("payout"),
+  object: z27.literal("payout"),
   creator_id: idOf("crt"),
   amount_micro_usd: MicroUsdField.positive(),
-  currency: z26.literal("USD"),
+  currency: z27.literal("USD"),
   method: PayoutMethodSchema,
-  account: z26.string().min(1),
+  account: z27.string().min(1),
   status: PayoutStatusSchema,
-  reference: z26.string().nullable(),
-  note: z26.string().nullable(),
+  reference: z27.string().nullable(),
+  note: z27.string().nullable(),
   requested_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
 var CREATOR_PROGRAM = {
-  referral_percent: 20,
-  template_percent: 5,
+  referral_percent: 15,
+  /** Of each qualifying subscription invoice of an org whose FIRST install was the template. */
+  template_percent: 15,
   commission_months: 12,
   hold_days: 30,
   attribution_days: 30,
-  minimum_payout_micro_usd: 2e7
+  /** A template install earns only for an org it was installed in within this many days of creation. */
+  template_new_org_days: 35,
+  minimum_payout_micro_usd: 2e7,
+  /** The creator studio's per-draft spend caps; one session never plans past what the draft has left. */
+  studio: {
+    draft_budget_micro_usd: 4e7,
+    author_budget_micro_usd: 8e6,
+    demo_budget_micro_usd: 1e7,
+    uploads: 3,
+    upload_max_bytes: 60 * 1024 * 1024,
+    upload_token_minutes: 15,
+    skill_max_bytes: 32 * 1024
+  }
 };
-var CreatorTemplateSlugSchema = z26.string().max(32).regex(
+var CreatorTemplateSlugSchema = z27.string().max(32).regex(
   /^[a-z0-9]+(-[a-z0-9]+)*$/,
   "lowercase letters, digits and single dashes"
 );
-var CreatorSkillSchema = z26.object({
-  slug: z26.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  body: z26.string().min(1).max(64 * 1024)
-});
-var CreatorDeclarationSchema = z26.object({
-  agents: z26.array(z26.unknown()),
-  questions: z26.array(z26.unknown()),
-  skills: z26.array(CreatorSkillSchema).max(16)
-});
-var CreatorTemplateVersionStatusSchema = z26.enum([
+var CreatorSkillSchema = z27.object({
+  slug: z27.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
+  body: z27.string().min(1).max(64 * 1024)
+});
+var CreatorDeclarationSchema = z27.object({
+  agents: z27.array(z27.unknown()),
+  questions: z27.array(z27.unknown()),
+  skills: z27.array(CreatorSkillSchema).max(16),
+  /** A `niche` version only: the studio round it froze (see `NicheVersionStudioSchema`, below). */
+  studio: z27.lazy(() => NicheVersionStudioSchema).optional()
+});
+var CreatorTemplateVersionStatusSchema = z27.enum([
   "in_review",
   "approved",
   "changes_requested"
 ]);
-var VersionNumber = z26.number().int().positive();
-var CreatorTemplateSchema = z26.object({
+var VersionNumber = z27.number().int().positive();
+var CreatorTemplateKindSchema = z27.enum(["crew", "niche"]);
+var StudioStateSchema = z27.enum([
+  "setup",
+  "building",
+  "ready",
+  "in_review",
+  "live",
+  "changes_requested"
+]);
+var StudioUploadContentTypeSchema = z27.enum([
+  "video/mp4",
+  "video/quicktime",
+  "video/webm"
+]);
+var UploadPosition = z27.number().int().min(1).max(CREATOR_PROGRAM.studio.uploads);
+var StudioPrompt = z27.string().max(2e3);
+var StudioUploadSchema = z27.object({
+  position: UploadPosition,
+  file_id: z27.string().nullable(),
+  prompt: StudioPrompt,
+  bytes: z27.number().int().positive().max(CREATOR_PROGRAM.studio.upload_max_bytes),
+  content_type: StudioUploadContentTypeSchema,
+  filename: z27.string().min(1).max(200)
+});
+var CreatorStudioSchema = z27.object({
+  uploads: z27.array(StudioUploadSchema).max(CREATOR_PROGRAM.studio.uploads).default([]),
+  state: StudioStateSchema.default("setup"),
+  spend_micro_usd: MicroUsdField.nonnegative().default(0),
+  rights_attested_at: Timestamp.nullable().default(null)
+});
+var CreatorTemplateListingSchema = z27.object({
+  listed: z27.boolean(),
+  featured: z27.boolean(),
+  sort_order: z27.number().int(),
+  tagline: z27.string().max(140).nullable(),
+  hero_file_id: z27.string().nullable()
+});
+var StudioRoundStateSchema = z27.enum([
+  "queued",
+  "authoring",
+  "rendering",
+  "ready",
+  "failed"
+]);
+var StudioFrameSchema = z27.object({
+  file: z27.string().min(1),
+  file_id: z27.string().min(1),
+  role: z27.string()
+});
+var StudioSampleSchema = z27.object({
+  file_id: z27.string().min(1),
+  poster_file_id: z27.string().nullable(),
+  seconds: z27.number().nonnegative(),
+  title: z27.string()
+});
+var CreatorTemplateRoundSchema = z27.object({
+  object: z27.literal("creator_template_round"),
+  template_id: idOf("ctp"),
+  n: z27.number().int().positive(),
+  feedback: z27.string().nullable(),
+  state: StudioRoundStateSchema,
+  author_session_id: z27.string().nullable(),
+  demo_session_id: z27.string().nullable(),
+  skill_md: z27.string().nullable(),
+  reference_json: z27.unknown().nullable(),
+  frames: z27.array(StudioFrameSchema),
+  samples: z27.array(StudioSampleSchema),
+  spend_micro_usd: MicroUsdField.nonnegative(),
+  error: z27.string().nullable(),
+  created_at: Timestamp,
+  finished_at: Timestamp.nullable()
+});
+var NicheVersionStudioSchema = z27.object({
+  round: z27.number().int().positive(),
+  uploads: z27.array(StudioUploadSchema),
+  reference_json: z27.unknown().nullable(),
+  frames: z27.array(StudioFrameSchema),
+  samples: z27.array(StudioSampleSchema),
+  tagline: z27.string().max(140),
+  hero_sample_index: z27.number().int().nonnegative()
+});
+var CreatorTemplateSchema = z27.object({
   id: idOf("ctp"),
-  object: z26.literal("creator_template"),
+  object: z27.literal("creator_template"),
   creator_id: idOf("crt"),
-  blueprint: z26.string().min(1),
-  base_template: z26.string().min(1),
+  blueprint: z27.string().min(1),
+  base_template: z27.string().min(1),
   slug: CreatorTemplateSlugSchema,
-  template: z26.string().min(1).max(64),
-  name: z26.string().min(1).max(80),
-  description: z26.string().max(2e3),
+  template: z27.string().min(1).max(64),
+  name: z27.string().min(1).max(80),
+  description: z27.string().max(2e3),
   declaration: CreatorDeclarationSchema,
   published_version: VersionNumber.nullable(),
-  latest_version: z26.object({
+  latest_version: z27.object({
     version: VersionNumber,
     status: CreatorTemplateVersionStatusSchema
   }).nullable(),
+  kind: CreatorTemplateKindSchema,
+  studio: CreatorStudioSchema,
+  listing: CreatorTemplateListingSchema,
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreatorTemplateVersionSchema = z26.object({
-  object: z26.literal("creator_template_version"),
+var CreatorTemplateVersionSchema = z27.object({
+  object: z27.literal("creator_template_version"),
   template_id: idOf("ctp"),
   version: VersionNumber,
   declaration: CreatorDeclarationSchema,
   status: CreatorTemplateVersionStatusSchema,
-  note: z26.string().nullable(),
+  note: z27.string().nullable(),
   artifact_id: idOf("bpa").nullable(),
   submitted_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var CreatorBalanceSchema = z26.object({
-  object: z26.literal("creator_balance"),
+var CreatorBalanceSchema = z27.object({
+  object: z27.literal("creator_balance"),
   pending_micro_usd: MicroUsdField.nonnegative(),
   available_micro_usd: MicroUsdField.nonnegative(),
   claimed_micro_usd: MicroUsdField.nonnegative(),
   paid_micro_usd: MicroUsdField.nonnegative(),
-  minimum_payout_micro_usd: z26.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
+  minimum_payout_micro_usd: z27.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
 });
-var ReferralClickSchema = z26.object({
-  object: z26.literal("referral_click"),
+var ReferralClickSchema = z27.object({
+  object: z27.literal("referral_click"),
   code: CreatorCodeSchema,
-  creator: z26.object({ display_name: z26.string().min(1) }),
+  creator: z27.object({ display_name: z27.string().min(1) }),
   expires_at: Timestamp
 });
-var Day2 = z26.iso.date();
-var CreatorAnalyticsSchema = z26.object({
-  object: z26.literal("creator_analytics"),
-  days: z26.number().int().min(1).max(90),
+var Day2 = z27.iso.date();
+var CreatorAnalyticsSchema = z27.object({
+  object: z27.literal("creator_analytics"),
+  days: z27.number().int().min(1).max(90),
   from: Day2,
   to: Day2,
-  clicks: z26.number().int().nonnegative(),
-  referrals: z26.number().int().nonnegative(),
-  installs: z26.number().int().nonnegative(),
-  active_installs: z26.number().int().nonnegative(),
-  usage_by_day: z26.array(
-    z26.object({ day: Day2, debit_micro_usd: MicroUsdField.nonnegative() })
-  ),
-  commission_micro_usd: z26.object({
+  clicks: z27.number().int().nonnegative(),
+  referrals: z27.number().int().nonnegative(),
+  installs: z27.number().int().nonnegative(),
+  active_installs: z27.number().int().nonnegative(),
+  /** Distinct orgs with at least one commission-bearing invoice in the window (invoice-based template commission). */
+  paying_orgs: z27.number().int().nonnegative().optional(),
+  /** DEPRECATED with the 5% usage accrual; optional until `analytics()` stops returning it. */
+  usage_by_day: z27.array(z27.object({ day: Day2, debit_micro_usd: MicroUsdField.nonnegative() })).optional(),
+  commission_micro_usd: z27.object({
     pending: MicroUsdField.nonnegative(),
     available: MicroUsdField.nonnegative(),
     claimed: MicroUsdField.nonnegative(),
     paid: MicroUsdField.nonnegative()
   }),
-  commissions_by_template: z26.array(
-    z26.object({
+  commissions_by_template: z27.array(
+    z27.object({
       creator_template_id: idOf("ctp"),
       amount_micro_usd: MicroUsdField.nonnegative()
     })
   ),
   /** Every install covered, newest first: the day it was created and the day its twelve months end. */
-  install_windows: z26.array(z26.object({ install_id: idOf("bpi"), from: Day2, until: Day2 }))
+  install_windows: z27.array(z27.object({ install_id: idOf("bpi"), from: Day2, until: Day2 })).optional()
+});
+var CreatorTemplateCreateKindSchema = z27.object({
+  kind: CreatorTemplateKindSchema.default("crew")
+});
+var StudioUploadCreateSchema = z27.object({
+  position: UploadPosition,
+  filename: z27.string().min(1).max(200),
+  content_type: StudioUploadContentTypeSchema,
+  bytes: z27.number().int().positive().max(CREATOR_PROGRAM.studio.upload_max_bytes)
+});
+var StudioUploadTicketSchema = z27.object({
+  object: z27.literal("studio_upload_ticket"),
+  position: UploadPosition,
+  upload_url: z27.url(),
+  expires_at: Timestamp
+});
+var StudioUploadPatchSchema = z27.object({ prompt: StudioPrompt });
+var StudioUploadResultSchema = z27.object({
+  object: z27.literal("studio_upload"),
+  template_id: idOf("ctp"),
+  upload: StudioUploadSchema
+});
+var StudioRoundCreateSchema = z27.object({
+  feedback: z27.string().min(1).max(4e3).optional(),
+  rights_attested: z27.boolean().optional()
+});
+var StudioBudgetSchema = z27.object({
+  draft_micro_usd: MicroUsdField.nonnegative(),
+  spent_micro_usd: MicroUsdField.nonnegative(),
+  remaining_micro_usd: MicroUsdField.nonnegative()
+});
+var CreatorStudioViewSchema = z27.object({
+  object: z27.literal("creator_studio"),
+  template_id: idOf("ctp"),
+  studio: CreatorStudioSchema,
+  /** Newest first. */
+  rounds: z27.array(CreatorTemplateRoundSchema),
+  budget: StudioBudgetSchema
+});
+var NicheSubmitSchema = z27.object({
+  round: z27.number().int().positive(),
+  listing: z27.object({
+    tagline: z27.string().min(1).max(140),
+    hero_sample_index: z27.number().int().nonnegative()
+  })
+});
+var CreatorListingPatchSchema = CreatorTemplateListingSchema.partial();
+var CreatorListingSchema = z27.object({
+  object: z27.literal("creator_listing"),
+  template_id: idOf("ctp"),
+  template: z27.string().min(1),
+  name: z27.string(),
+  kind: CreatorTemplateKindSchema,
+  blueprint: z27.string(),
+  base_template: z27.string(),
+  published_version: VersionNumber.nullable(),
+  creator: z27.object({
+    id: idOf("crt"),
+    display_name: z27.string(),
+    code: CreatorCodeSchema,
+    status: CreatorStatusSchema
+  }),
+  listing: CreatorTemplateListingSchema,
+  /** Installs of the template, and distinct orgs among them that earned a template commission. */
+  deploys: z27.number().int().nonnegative().optional(),
+  paying_orgs: z27.number().int().nonnegative().optional(),
+  updated_at: Timestamp
 });
 
 // ../core/src/schema/legal.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var LEGAL_MEMBER_STATUSES = [
   "pending",
   "link_ready",
@@ -2708,16 +3104,16 @@ var LEGAL_MEMBER_STATUSES = [
   "verified",
   "failed"
 ];
-var LegalMemberStatusSchema = z27.enum(LEGAL_MEMBER_STATUSES);
+var LegalMemberStatusSchema = z28.enum(LEGAL_MEMBER_STATUSES);
 var LEGAL_VERIFICATION_STATUSES = ["in_progress", "pending_review", "verified", "failed"];
-var LegalVerificationStatusSchema = z27.enum(LEGAL_VERIFICATION_STATUSES);
+var LegalVerificationStatusSchema = z28.enum(LEGAL_VERIFICATION_STATUSES);
 var LEGAL_COMPANY_STATUSES = ["awaiting_payment", "paid", "submitted", "formed", "failed"];
-var LegalCompanyStatusSchema = z27.enum(LEGAL_COMPANY_STATUSES);
+var LegalCompanyStatusSchema = z28.enum(LEGAL_COMPANY_STATUSES);
 var LEGAL_DOCUMENT_KINDS = ["articles", "ein_letter", "operating_agreement", "other"];
-var LegalDocumentKindSchema = z27.enum(LEGAL_DOCUMENT_KINDS);
-var LegalMemberRoleSchema = z27.enum(["primary", "secondary"]);
-var LegalEinStatusSchema = z27.enum(["none", "pending", "issued"]);
-var LegalRequiredActionKindSchema = z27.enum(["signature", "information", "payment", "other"]);
+var LegalDocumentKindSchema = z28.enum(LEGAL_DOCUMENT_KINDS);
+var LegalMemberRoleSchema = z28.enum(["primary", "secondary"]);
+var LegalEinStatusSchema = z28.enum(["none", "pending", "issued"]);
+var LegalRequiredActionKindSchema = z28.enum(["signature", "information", "payment", "other"]);
 var US_STATES = [
   "AL",
   "AK",
@@ -2771,105 +3167,105 @@ var US_STATES = [
   "WI",
   "WY"
 ];
-var UsStateSchema = z27.enum(US_STATES);
-var LegalMemberInputSchema = z27.object({
-  first_name: z27.string().min(1).max(128),
-  last_name: z27.string().min(1).max(128),
-  email: z27.string().min(1).max(320),
+var UsStateSchema = z28.enum(US_STATES);
+var LegalMemberInputSchema = z28.object({
+  first_name: z28.string().min(1).max(128),
+  last_name: z28.string().min(1).max(128),
+  email: z28.string().min(1).max(320),
   role: LegalMemberRoleSchema,
-  is_responsible_party: z27.boolean(),
-  ownership_percent: z27.number().int()
+  is_responsible_party: z28.boolean(),
+  ownership_percent: z28.number().int()
 });
 var LegalMemberSchema = LegalMemberInputSchema.extend({
   id: idOf("lgm"),
-  object: z27.literal("legal_member"),
+  object: z28.literal("legal_member"),
   verification_id: idOf("lgv"),
   status: LegalMemberStatusSchema,
-  link_url: z27.url().nullable(),
+  link_url: z28.url().nullable(),
   link_expires_at: Timestamp.nullable(),
   completed_at: Timestamp.nullable()
 });
-var LegalVerificationSchema = z27.object({
+var LegalVerificationSchema = z28.object({
   id: idOf("lgv"),
-  object: z27.literal("legal_verification"),
+  object: z28.literal("legal_verification"),
   identity_id: idOf("idn"),
   status: LegalVerificationStatusSchema,
-  members: z27.array(LegalMemberSchema),
-  ready_for_formation: z27.boolean(),
+  members: z28.array(LegalMemberSchema),
+  ready_for_formation: z28.boolean(),
   started_at: Timestamp,
   completed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var StartLegalVerificationSchema = z27.object({ members: z27.array(LegalMemberInputSchema) });
-var CompleteLegalMemberSchema = z27.object({ token: z27.string().min(1) });
-var LegalNameOptionSchema = z27.object({ name: z27.string().min(1).max(200), ending: z27.literal("LLC") });
-var LegalMailingAddressSchema = z27.object({
-  line1: z27.string().min(1).max(200),
-  line2: z27.string().max(200).nullable(),
-  city: z27.string().min(1).max(100),
+var StartLegalVerificationSchema = z28.object({ members: z28.array(LegalMemberInputSchema) });
+var CompleteLegalMemberSchema = z28.object({ token: z28.string().min(1) });
+var LegalNameOptionSchema = z28.object({ name: z28.string().min(1).max(200), ending: z28.literal("LLC") });
+var LegalMailingAddressSchema = z28.object({
+  line1: z28.string().min(1).max(200),
+  line2: z28.string().max(200).nullable(),
+  city: z28.string().min(1).max(100),
   state: UsStateSchema,
-  postal_code: z27.string().min(1).max(16),
-  country: z27.literal("US")
+  postal_code: z28.string().min(1).max(16),
+  country: z28.literal("US")
 });
-var LegalRequiredActionSchema = z27.object({
+var LegalRequiredActionSchema = z28.object({
   kind: LegalRequiredActionKindSchema,
-  description: z27.string(),
-  url: z27.url().nullable()
+  description: z28.string(),
+  url: z28.url().nullable()
 });
 var LEGAL_DESCRIPTION_MAX = 50;
-var CreateLegalCompanySchema = z27.object({
+var CreateLegalCompanySchema = z28.object({
   verification_id: idOf("lgv"),
   state: UsStateSchema,
-  name_options: z27.array(z27.string().min(1).max(200)).min(1).max(3),
-  naics_code: z27.string().regex(/^\d{2,6}$/),
-  description: z27.string().min(1).max(LEGAL_DESCRIPTION_MAX),
+  name_options: z28.array(z28.string().min(1).max(200)).min(1).max(3),
+  naics_code: z28.string().regex(/^\d{2,6}$/),
+  description: z28.string().min(1).max(LEGAL_DESCRIPTION_MAX),
   mailing_address: LegalMailingAddressSchema
 });
 var LegalCompanySchema = CreateLegalCompanySchema.omit({ name_options: true }).extend({
   id: idOf("lgc"),
-  object: z27.literal("legal_company"),
+  object: z28.literal("legal_company"),
   identity_id: idOf("idn"),
   status: LegalCompanyStatusSchema,
-  entity_type: z27.literal("llc"),
-  name_options: z27.array(LegalNameOptionSchema),
-  legal_name: z27.string().nullable(),
+  entity_type: z28.literal("llc"),
+  name_options: z28.array(LegalNameOptionSchema),
+  legal_name: z28.string().nullable(),
   ein_status: LegalEinStatusSchema,
   price_micro_usd: MicroUsdField,
-  required_actions: z27.array(LegalRequiredActionSchema),
-  failure_reason: z27.string().max(256).nullable(),
+  required_actions: z28.array(LegalRequiredActionSchema),
+  failure_reason: z28.string().max(256).nullable(),
   submitted_at: Timestamp.nullable(),
   formed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var LegalDocumentSchema = z27.object({
+var LegalDocumentSchema = z28.object({
   id: idOf("lgd"),
-  object: z27.literal("legal_document"),
+  object: z28.literal("legal_document"),
   company_id: idOf("lgc"),
   kind: LegalDocumentKindSchema,
-  name: z27.string(),
+  name: z28.string(),
   created_at: Timestamp
 });
-var LegalDocumentLinkSchema = z27.object({
-  object: z27.literal("legal_document_link"),
-  url: z27.url(),
+var LegalDocumentLinkSchema = z28.object({
+  object: z28.literal("legal_document_link"),
+  url: z28.url(),
   expires_at: Timestamp
 });
-var NaicsCodeSchema = z27.object({
-  object: z27.literal("naics_code"),
-  code: z27.string().regex(/^\d{2,6}$/),
-  title: z27.string()
+var NaicsCodeSchema = z28.object({
+  object: z28.literal("naics_code"),
+  code: z28.string().regex(/^\d{2,6}$/),
+  title: z28.string()
 });
-var LegalStateSchema = z27.object({
-  object: z27.literal("legal_state"),
+var LegalStateSchema = z28.object({
+  object: z28.literal("legal_state"),
   code: UsStateSchema,
-  name: z27.string(),
+  name: z28.string(),
   formation_fee_micro_usd: MicroUsdField
 });
-var LegalWebhookEventSchema = z27.object({
-  provider_session_ref: z27.string().min(1),
-  status: z27.enum(["verified", "failed", "pending_review"]),
+var LegalWebhookEventSchema = z28.object({
+  provider_session_ref: z28.string().min(1),
+  status: z28.enum(["verified", "failed", "pending_review"]),
   metadata: Metadata
 });
 var LLC_ENDING = /\s*(?:,\s*)?(?:l\.?l\.?c\.?|limited\s+liability\s+company)\s*$/i;
@@ -2880,419 +3276,302 @@ function canonicalName(raw) {
 }
 
 // ../core/src/schema/wallet.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var WALLET_NETWORKS = ["eip155:84532", "eip155:8453"];
-var WalletNetworkSchema = z28.enum(WALLET_NETWORKS);
+var WalletNetworkSchema = z29.enum(WALLET_NETWORKS);
 var DEFAULT_WALLET_NETWORK = "eip155:84532";
-var WalletSelectSchema = z28.object({ network: WalletNetworkSchema.optional() });
+var WalletSelectSchema = z29.object({ network: WalletNetworkSchema.optional() });
 var WALLET_STATUSES = ["active", "frozen", "swept"];
-var WalletStatusSchema = z28.enum(WALLET_STATUSES);
+var WalletStatusSchema = z29.enum(WALLET_STATUSES);
 var WALLET_TRANSACTION_KINDS = ["fund", "transfer", "pay", "sweep"];
-var WalletTransactionKindSchema = z28.enum(WALLET_TRANSACTION_KINDS);
+var WalletTransactionKindSchema = z29.enum(WALLET_TRANSACTION_KINDS);
 var WALLET_TRANSACTION_STATUSES = ["pending", "confirmed", "failed"];
-var WalletTransactionStatusSchema = z28.enum(WALLET_TRANSACTION_STATUSES);
-var WalletDirectionSchema = z28.enum(["in", "out"]);
-var WalletFundSourceSchema = z28.enum(["faucet", "treasury"]);
-var EvmAddressSchema = z28.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x address");
-var TxHashSchema = z28.string().regex(/^0x[0-9a-fA-F]{64}$/, "expected a 0x transaction hash");
-var WalletPolicySchema = z28.object({
+var WalletTransactionStatusSchema = z29.enum(WALLET_TRANSACTION_STATUSES);
+var WalletDirectionSchema = z29.enum(["in", "out"]);
+var WalletFundSourceSchema = z29.enum(["faucet", "treasury"]);
+var EvmAddressSchema = z29.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x address");
+var TxHashSchema = z29.string().regex(/^0x[0-9a-fA-F]{64}$/, "expected a 0x transaction hash");
+var WalletPolicySchema = z29.object({
   per_tx_cap_micro_usd: MicroUsdField.nonnegative(),
   daily_cap_micro_usd: MicroUsdField.positive().nullable(),
   low_balance_micro_usd: MicroUsdField.nonnegative().nullable()
 });
-var WalletSchema = z28.object({
+var WalletSchema = z29.object({
   id: idOf("wlt"),
-  object: z28.literal("wallet"),
+  object: z29.literal("wallet"),
   identity_id: idOf("idn"),
   status: WalletStatusSchema,
   network: WalletNetworkSchema,
   address: EvmAddressSchema,
-  asset: z28.literal("usdc"),
+  asset: z29.literal("usdc"),
   balance_micro_usd: MicroUsdField,
   policy: WalletPolicySchema,
   spent_today_micro_usd: MicroUsdField,
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreateWalletSchema = z28.object({
+var CreateWalletSchema = z29.object({
   network: WalletNetworkSchema.optional(),
   policy: WalletPolicySchema.partial().optional()
 });
 var UpdateWalletPolicySchema = WalletPolicySchema.partial();
-var FundWalletSchema = z28.object({
+var FundWalletSchema = z29.object({
   amount_micro_usd: MicroUsdField.positive(),
   source: WalletFundSourceSchema
 });
-var TransferWalletSchema = z28.object({
-  to: z28.union([EvmAddressSchema, idOf("idn")]),
+var TransferWalletSchema = z29.object({
+  to: z29.union([EvmAddressSchema, idOf("idn")]),
   amount_micro_usd: MicroUsdField.positive(),
-  purpose: z28.string().min(1).max(256)
+  purpose: z29.string().min(1).max(256)
 });
-var SweepWalletSchema = z28.object({ to: EvmAddressSchema.optional() });
-var WalletTransactionSchema = z28.object({
+var SweepWalletSchema = z29.object({ to: EvmAddressSchema.optional() });
+var WalletTransactionSchema = z29.object({
   id: idOf("wtx"),
-  object: z28.literal("wallet_transaction"),
+  object: z29.literal("wallet_transaction"),
   wallet_id: idOf("wlt"),
   kind: WalletTransactionKindSchema,
   direction: WalletDirectionSchema,
   amount_micro_usd: MicroUsdField,
-  counterparty: z28.string().nullable(),
-  origin: z28.string().nullable(),
-  purpose: z28.string().nullable(),
+  counterparty: z29.string().nullable(),
+  origin: z29.string().nullable(),
+  purpose: z29.string().nullable(),
   tx_hash: TxHashSchema.nullable(),
   session_id: idOf("ses").nullable(),
   status: WalletTransactionStatusSchema,
   created_at: Timestamp
 });
-var ListWalletTransactionsSchema = z28.object({
+var ListWalletTransactionsSchema = z29.object({
   kind: WalletTransactionKindSchema.optional(),
   direction: WalletDirectionSchema.optional(),
-  origin: z28.string().optional(),
+  origin: z29.string().optional(),
   since: Timestamp.optional()
 });
-var HttpMethodSchema = z28.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-var WalletQuoteRequestSchema = z28.object({ url: z28.url(), method: HttpMethodSchema.optional() });
-var WalletQuoteSchema = z28.object({
-  object: z28.literal("wallet_quote"),
-  url: z28.url(),
-  payable: z28.boolean(),
+var HttpMethodSchema = z29.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var WalletQuoteRequestSchema = z29.object({ url: z29.url(), method: HttpMethodSchema.optional() });
+var WalletQuoteSchema = z29.object({
+  object: z29.literal("wallet_quote"),
+  url: z29.url(),
+  payable: z29.boolean(),
   network: WalletNetworkSchema.nullable(),
-  asset: z28.literal("usdc").nullable(),
+  asset: z29.literal("usdc").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
   pay_to: EvmAddressSchema.nullable(),
-  description: z28.string().nullable(),
-  max_timeout_seconds: z28.number().int().nullable()
+  description: z29.string().nullable(),
+  max_timeout_seconds: z29.number().int().nullable()
 });
 var WalletPayRequestSchema = WalletQuoteRequestSchema.extend({
   max_amount_micro_usd: MicroUsdField.positive().optional()
 });
 var WALLET_RESPONSE_BODY_MAX = 64 * 1024;
-var WalletPaymentSchema = z28.object({
-  object: z28.literal("wallet_payment"),
-  paid: z28.boolean(),
+var WalletPaymentSchema = z29.object({
+  object: z29.literal("wallet_payment"),
+  paid: z29.boolean(),
   transaction_id: idOf("wtx").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
-  response_status: z28.number().int(),
-  response_body: z28.string().max(WALLET_RESPONSE_BODY_MAX)
+  response_status: z29.number().int(),
+  response_body: z29.string().max(WALLET_RESPONSE_BODY_MAX)
 });
 
 // ../core/src/schema/cards.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var CARD_STATUSES = ["pending_payment", "issuing", "active", "failed", "cancelled", "refunded"];
-var CardStatusSchema = z29.enum(CARD_STATUSES);
+var CardStatusSchema = z30.enum(CARD_STATUSES);
 var CARD_MIN_LOAD_MICRO_USD = 1e6;
 var CARD_MAX_LOAD_MICRO_USD = 15e7;
 var CARD_LOAD_GRANULARITY_MICRO_USD = 1e4;
-var CardSchema = z29.object({
+var CardSchema = z30.object({
   id: idOf("vcd"),
-  object: z29.literal("card"),
+  object: z30.literal("card"),
   identity_id: idOf("idn"),
-  kind: z29.literal("prepaid"),
+  kind: z30.literal("prepaid"),
   status: CardStatusSchema,
-  label: z29.string().min(1).max(128),
-  brand: z29.string().nullable(),
-  last4: z29.string().regex(/^\d{4}$/).nullable(),
+  label: z30.string().min(1).max(128),
+  brand: z30.string().nullable(),
+  last4: z30.string().regex(/^\d{4}$/).nullable(),
   load_micro_usd: MicroUsdField,
   spent_micro_usd: MicroUsdField,
-  currency: z29.literal("usd"),
+  currency: z30.literal("usd"),
   expires_at: Timestamp.nullable(),
-  failure_reason: z29.string().max(256).nullable(),
+  failure_reason: z30.string().max(256).nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var IssueCardSchema = z29.object({
+var IssueCardSchema = z30.object({
   label: CardSchema.shape.label,
   load_micro_usd: MicroUsdField.min(CARD_MIN_LOAD_MICRO_USD).max(CARD_MAX_LOAD_MICRO_USD).multipleOf(CARD_LOAD_GRANULARITY_MICRO_USD)
 });
 var CardQuoteRequestSchema = IssueCardSchema.pick({ load_micro_usd: true });
-var CardQuoteSchema = z29.object({
-  object: z29.literal("card_quote"),
+var CardQuoteSchema = z30.object({
+  object: z30.literal("card_quote"),
   load_micro_usd: MicroUsdField,
   price_micro_usd: MicroUsdField,
-  brand: z29.string().nullable(),
+  brand: z30.string().nullable(),
   min_load_micro_usd: MicroUsdField,
   max_load_micro_usd: MicroUsdField
 });
-var CardCredentialsSchema = z29.object({
-  object: z29.literal("card_credentials"),
+var CardCredentialsSchema = z30.object({
+  object: z30.literal("card_credentials"),
   card_id: idOf("vcd"),
-  number: z29.string().min(1),
-  pin: z29.string().nullable(),
-  cvv: z29.string().nullable(),
-  expiry: z29.string().nullable(),
-  url: z29.url().nullable(),
-  instructions: z29.string().nullable(),
+  number: z30.string().min(1),
+  pin: z30.string().nullable(),
+  cvv: z30.string().nullable(),
+  expiry: z30.string().nullable(),
+  url: z30.url().nullable(),
+  instructions: z30.string().nullable(),
   revealed_at: Timestamp
 });
-var CardTransactionSchema = z29.object({
+var CardTransactionSchema = z30.object({
   id: idOf("vct"),
-  object: z29.literal("card_transaction"),
+  object: z30.literal("card_transaction"),
   card_id: idOf("vcd"),
   amount_micro_usd: MicroUsdField,
-  merchant: z29.string().nullable(),
-  description: z29.string().nullable(),
+  merchant: z30.string().nullable(),
+  description: z30.string().nullable(),
   session_id: idOf("ses").nullable(),
   metadata: Metadata,
   created_at: Timestamp
 });
-var LogCardTransactionSchema = z29.object({
+var LogCardTransactionSchema = z30.object({
   amount_micro_usd: MicroUsdField.positive(),
-  merchant: z29.string().max(256).optional(),
-  description: z29.string().max(1024).optional(),
+  merchant: z30.string().max(256).optional(),
+  description: z30.string().max(1024).optional(),
   metadata: Metadata.optional()
 });
-var ListCardsSchema = z29.object({ status: CardStatusSchema.optional() });
+var ListCardsSchema = z30.object({ status: CardStatusSchema.optional() });
 
 // ../core/src/schema/proxy-trace.ts
-import { z as z30 } from "zod";
-var ProxyDialectSchema = z30.enum(["anthropic", "openai", "native"]);
-var ProxyTraceContentScopeSchema = z30.enum(["full", "metadata", "object"]);
-var TraceToolCall = z30.object({ id: z30.string().optional(), name: z30.string(), arguments: z30.string() });
-var ProxyTraceRequestSchema = z30.object({
-  model: z30.string().optional(),
+import { z as z31 } from "zod";
+var ProxyDialectSchema = z31.enum(["anthropic", "openai", "native"]);
+var ProxyTraceContentScopeSchema = z31.enum(["full", "metadata", "object"]);
+var TraceToolCall = z31.object({ id: z31.string().optional(), name: z31.string(), arguments: z31.string() });
+var ProxyTraceRequestSchema = z31.object({
+  model: z31.string().optional(),
   window: WindowSchema.optional(),
-  system: z30.string(),
-  messages: z30.array(
-    z30.looseObject({
-      role: z30.string(),
-      content: z30.string(),
-      tool_calls: z30.array(z30.looseObject({ id: z30.string(), name: z30.string() })).optional(),
-      tool_call_id: z30.string().optional()
+  system: z31.string(),
+  messages: z31.array(
+    z31.looseObject({
+      role: z31.string(),
+      content: z31.string(),
+      tool_calls: z31.array(z31.looseObject({ id: z31.string(), name: z31.string() })).optional(),
+      tool_call_id: z31.string().optional()
     })
   ),
-  tools: z30.array(z30.object({ name: z30.string(), description: z30.string(), parameters: z30.record(z30.string(), z30.unknown()) })).optional(),
-  tool_schema_hash: z30.string().optional(),
-  max_output_tokens: z30.number().int().optional(),
-  tool_names: z30.array(z30.string()).optional()
-});
-var ProxyTraceResponseSchema = z30.object({
-  text: z30.string(),
-  reasoning: z30.string().optional(),
-  reasoning_details: z30.array(z30.unknown()).optional(),
-  tool_calls: z30.array(TraceToolCall),
+  tools: z31.array(z31.object({ name: z31.string(), description: z31.string(), parameters: z31.record(z31.string(), z31.unknown()) })).optional(),
+  tool_schema_hash: z31.string().optional(),
+  max_output_tokens: z31.number().int().optional(),
+  tool_names: z31.array(z31.string()).optional()
+});
+var ProxyTraceResponseSchema = z31.object({
+  text: z31.string(),
+  reasoning: z31.string().optional(),
+  reasoning_details: z31.array(z31.unknown()).optional(),
+  tool_calls: z31.array(TraceToolCall),
   /** A call that threw, was abandoned or never completed (ADR-0794): the reply is what streamed before. */
-  is_error: z30.literal(true).optional(),
+  is_error: z31.literal(true).optional(),
   /** The error's class name — never its message — or `incomplete` for a stream that just stopped. */
-  error_class: z30.string().optional(),
-  partial: z30.literal(true).optional()
+  error_class: z31.string().optional(),
+  partial: z31.literal(true).optional()
 });
-var Sha256 = z30.string().regex(/^[0-9a-f]{64}$/);
-var ProxyCallTraceSchema = z30.object({
+var Sha256 = z31.string().regex(/^[0-9a-f]{64}$/);
+var ProxyCallTraceSchema = z31.object({
   /** The request id: also `x-request-id`, the reply's `id`, and the ledger entry's idempotency key. */
   id: idOf("req"),
-  object: z30.literal("proxy_call_trace"),
+  object: z31.literal("proxy_call_trace"),
   dialect: ProxyDialectSchema,
   /** The principal that made the call (§17). An API key here is the answer to "who sent this". */
   actor: PrincipalSchema,
   /** The public model id the caller asked for. */
-  model: z30.string(),
+  model: z31.string(),
   window: WindowSchema,
   /** The model the reply said served it — where `vetta/auto` resolves — or null if it named none. */
-  resolved_model: z30.string().nullable(),
+  resolved_model: z31.string().nullable(),
   /**
    * The serving provider and the gateway's own generation id. Null on every row written before the
    * adapter stops dropping them (Track A); together they are what lets an upstream invoice line be
    * matched back to an organization, a key and a ledger entry.
    */
-  provider: z30.string().nullable(),
-  generation_id: z30.string().nullable(),
-  stop: z30.enum(["end_turn", "tool_use", "length"]).nullable(),
+  provider: z31.string().nullable(),
+  generation_id: z31.string().nullable(),
+  stop: z31.enum(["end_turn", "tool_use", "length"]).nullable(),
   usage: TokenUsageSchema,
   /** What the customer was charged, µUSD. The ledger entry is the authority; this is its copy. */
   billed_micro_usd: MicroUsdField.nullable(),
   /** What the vendor said it cost, µUSD. A CROSS-CHECK, NEVER A DEBIT. */
   vendor_cost_micro_usd: MicroUsdField.nullable(),
-  duration_ms: z30.number().int().nonnegative().nullable(),
+  duration_ms: z31.number().int().nonnegative().nullable(),
   content_scope: ProxyTraceContentScopeSchema,
   /** `proxy` — a `/v1/proxy/*` call; `harness` — a hosted harness's own model call (ADR-0762). */
-  source: z30.enum(["proxy", "harness"]),
+  source: z31.enum(["proxy", "harness"]),
   /** The session the call belongs to: a harness call's, or a sandbox token's `sub` on the proxy. */
-  session_id: z30.string().nullable(),
+  session_id: z31.string().nullable(),
   /**
    * The `seq` of the call's `span.model_request.end` event — or of its `.start` when the call failed
    * or its `.end` was withheld (ADR-0794). Null on the proxy, which writes no event.
    */
-  seq: z30.number().int().nullable(),
+  seq: z31.number().int().nullable(),
   /** The board card the session was woken for (`session.metadata.board.card_id`), or null. */
-  board_card_id: z30.string().nullable(),
+  board_card_id: z31.string().nullable(),
   /** The ids of the tool calls this reply made — the join to the `tool.*` events they caused. */
-  tool_call_ids: z30.array(z30.string()),
+  tool_call_ids: z31.array(z31.string()),
   /** sha-256 of the canonical JSON of the tool schema array the model was offered, or null. */
   tool_schema_hash: Sha256.nullable(),
   request_sha256: Sha256,
   response_sha256: Sha256,
   /** The UTF-8 size of each stored body. */
-  request_bytes: z30.number().int().nonnegative(),
-  response_bytes: z30.number().int().nonnegative(),
+  request_bytes: z31.number().int().nonnegative(),
+  response_bytes: z31.number().int().nonnegative(),
   /** Inline in `full` scope — every new row. Null on a legacy `metadata` or `object` row. */
   request: ProxyTraceRequestSchema.nullable(),
   response: ProxyTraceResponseSchema.nullable(),
   /** Always false since ADR-0762 (nothing is cut); true only on rows from before it. */
-  truncated: z30.boolean(),
+  truncated: z31.boolean(),
   created_at: Timestamp,
   /** When the reaper deletes this row. Null since ADR-0762: model I/O is kept, not expired. */
   expires_at: Timestamp.nullable()
 });
 
 // ../core/src/schema/review.ts
-import { z as z31 } from "zod";
-var ReviewDecisionSchema = z31.enum(["approve", "reject", "edit"]);
-var Fields = z31.record(z31.string().max(100), z31.unknown()).nullable().optional();
-var CreateReviewSchema = z31.object({
+import { z as z32 } from "zod";
+var ReviewDecisionSchema = z32.enum(["approve", "reject", "edit"]);
+var Fields = z32.record(z32.string().max(100), z32.unknown()).nullable().optional();
+var CreateReviewSchema = z32.object({
   decision: ReviewDecisionSchema,
-  reason: z31.string().max(4e3).nullable().optional(),
-  file_ids: z31.array(idOf("fil")).max(50).optional(),
+  reason: z32.string().max(4e3).nullable().optional(),
+  file_ids: z32.array(idOf("fil")).max(50).optional(),
   session_id: idOf("ses").optional(),
-  subject: z31.record(z31.string().max(100), z31.unknown()).optional(),
+  subject: z32.record(z32.string().max(100), z32.unknown()).optional(),
   before: Fields,
   after: Fields
 });
 
-// ../core/src/schema/mini-app.ts
-import { z as z32 } from "zod";
-var PAGE_BLOCKS = [
-  "Page",
-  "Section",
-  "Stack",
-  "Grid",
-  "Metric",
-  "LineChart",
-  "BarList",
-  "Progress",
-  "Roadmap",
-  "Schedule",
-  "Media",
-  "Text",
-  "Needs",
-  "Activity",
-  "Accounts",
-  "Posts",
-  "Answers",
-  "MediaLibrary"
-];
-var MAX_PAGE_ELEMENTS = 48;
-var MINI_APP_ICONS = ["grid", "list", "chart", "calendar", "play"];
-var MiniAppIconSchema = z32.enum(MINI_APP_ICONS);
-var SLUG = "[a-z][a-z0-9-]{0,39}";
-var MiniAppSlugSchema = z32.string().regex(new RegExp(`^${SLUG}$`), "a slug is lowercase letters, digits and -");
-var Place = z32.string().regex(new RegExp(`^/(board|connections|apps/${SLUG}(\\?page=${SLUG})?)$`), "a section links to /board, /connections or /apps/<slug>[?page=<slug>]");
-var POSTS = ["waiting", "scheduled", "posted"];
-var PostStatus = z32.enum(POSTS);
-var PostLayout = z32.enum(["list", "row", "grid"]);
-var PostStatuses = z32.union([PostStatus, z32.array(PostStatus).min(1).max(3).refine((all) => new Set(all).size === all.length, "each status once")]);
-var PageBound = {
-  ...Bound,
-  board: bound(["roadmap"], { per_group: z32.number().int().min(1).max(5).default(5) }),
-  media: bound(["latest_media", "newest_media"], { count: z32.number().int().min(1).max(6).default(4) })
-};
-var PageResolved = {
-  ...Resolved,
-  board: z32.strictObject({ $source: z32.literal("roadmap"), per_group: z32.number().int(), groups: RoadmapViewSchema.shape.groups }),
-  media: z32.array(z32.strictObject({ id: z32.string(), kind: z32.enum(["image", "video"]) })).max(6)
-};
-function pageBlocks(slot) {
-  return {
-    Page: element("Page", {}, box, "The page itself, the root and only the root."),
-    Section: element("Section", { title: words(40), to: Place.optional(), hide_empty: z32.boolean().optional() }, box, "A titled part of the page; hidden when every block in it is empty, if asked."),
-    Needs: element("Needs", { label, needs: slot.needs }, leaf, "What waits on a person: approvals, questions, spent caps."),
-    Activity: element("Activity", { label, agents: slot.agents }, leaf, "The agents working or waiting, and on what."),
-    Accounts: element("Accounts", { accounts: slot.accounts }, leaf, "The template's networks: connected with a handle, or not."),
-    Posts: element(
-      "Posts",
-      { label, layout: PostLayout.optional(), posts: slot.posts },
-      leaf,
-      "Posts waiting on a person, scheduled, or posted; several statuses make one list. Drawn as rows (list, the default), one sideways row of cards (row), or a picture grid (grid)."
-    ),
-    Answers: element("Answers", { answers: slot.answers }, leaf, "The setup's answers in one line, linking to the setup."),
-    // No binding: the studio's gallery reads and pages the company's files itself (ADR-0987).
-    MediaLibrary: element("MediaLibrary", {}, leaf, "Every picture and clip the company's agents made, with filters, sort and a viewer.")
-  };
-}
-var OwnBound = pageBlocks({
-  needs: bound(["needs"], {}),
-  agents: bound(["agents_activity"], {}),
-  accounts: bound(["accounts"], {}),
-  posts: bound(["posts"], { status: PostStatuses, limit: z32.number().int().min(1).max(50).default(10) }),
-  answers: bound(["answers"], { keys: z32.array(Key).min(1).max(TEMPLATE_QUESTIONS_MAX) })
-});
-var Need = z32.object({
-  session_id: z32.string(),
-  agent_id: z32.string(),
-  agent: z32.string(),
-  since: Timestamp,
-  /** The chat's stored title, or `null`: the studio names it by when it began. */
-  title: z32.string().nullable(),
-  kind: z32.enum(["tool", "question", "budget"]),
-  /** The call or question it is held on; `null` for a spent cap. */
-  action: PendingActionSchema.nullable()
-});
-var Working = z32.object({
-  agent_id: z32.string(),
-  agent: z32.string(),
-  state: z32.enum(["working", "waiting"]),
-  session_id: z32.string().nullable(),
-  title: z32.string().nullable(),
-  at: Timestamp
-});
-var OwnResolved = pageBlocks({
-  needs: z32.strictObject({ $source: z32.literal("needs"), items: z32.array(Need) }),
-  agents: z32.strictObject({ $source: z32.literal("agents_activity"), agents: z32.array(Working) }),
-  accounts: z32.strictObject({
-    $source: z32.literal("accounts"),
-    accounts: z32.array(z32.object({ platform: SocialPlatformSchema, connected: z32.boolean(), handle: z32.string().nullable() }))
-  }),
-  posts: z32.strictObject({ $source: z32.literal("posts"), status: z32.union([PostStatus, z32.array(PostStatus)]), limit: z32.number().int(), posts: z32.array(PostSchema), more: z32.boolean() }),
-  answers: z32.strictObject({
-    $source: z32.literal("answers"),
-    keys: z32.array(z32.string()),
-    values: z32.array(z32.string()),
-    template: z32.object({ blueprint: z32.string(), template: z32.string() }).nullable()
-  })
-});
-var BoundBlocks = { ...catalog(PageBound), ...OwnBound };
-var ResolvedBlocks = { ...catalog(PageResolved), ...OwnResolved };
-var Unread = element("Unread", { of: z32.string(), label: z32.string().nullable(), reason: z32.string() }, leaf, "A block that could not be read.");
-var B = BoundBlocks;
-var PageSpecSchema = spec(
-  z32.discriminatedUnion(
-    "type",
-    [B.Page, B.Section, B.Stack, B.Grid, B.Metric, B.LineChart, B.BarList, B.Progress, B.Roadmap, B.Schedule, B.Media, B.Text, B.Needs, B.Activity, B.Accounts, B.Posts, B.Answers, B.MediaLibrary],
-    unknownComponent(PAGE_BLOCKS)
-  ),
-  "Page",
-  MAX_PAGE_ELEMENTS
-);
-var R = ResolvedBlocks;
-var ResolvedPageElementSchema = z32.discriminatedUnion(
-  "type",
-  [R.Page, R.Section, R.Stack, R.Grid, R.Metric, R.LineChart, R.BarList, R.Progress, R.Roadmap, R.Schedule, R.Media, R.Text, R.Needs, R.Activity, R.Accounts, R.Posts, R.Answers, R.MediaLibrary, Unread],
-  unknownComponent(PAGE_BLOCKS)
-);
-var ResolvedPageSpecSchema = spec(ResolvedPageElementSchema, "Page", MAX_PAGE_ELEMENTS);
-var unique = (items) => new Set(items.map((item) => item.slug)).size === items.length;
-var MiniAppPageSchema = z32.strictObject({ slug: MiniAppSlugSchema, title: words(24), spec: PageSpecSchema });
-var MiniAppDeclSchema = z32.strictObject({
-  slug: MiniAppSlugSchema,
-  name: words(40),
-  icon: MiniAppIconSchema,
-  pages: z32.array(MiniAppPageSchema).min(1).max(6).refine(unique, "each page's slug is its own")
-});
-var MiniAppDeclsSchema = z32.array(MiniAppDeclSchema).max(8).refine(unique, "each mini app's slug is its own");
-var MiniAppSummarySchema = z32.object({
-  object: z32.literal("mini_app"),
-  slug: MiniAppSlugSchema,
-  name: z32.string(),
-  icon: MiniAppIconSchema,
-  pages: z32.array(z32.object({ slug: MiniAppSlugSchema, title: z32.string() })).min(1),
-  /** What it reads (`miniAppReads`). Absent from an older API: the Studio then claims nothing it cannot see. */
-  reads: z32.array(z32.string()).optional()
-});
-var MiniAppSchema = MiniAppSummarySchema.extend({
-  networks: z32.array(z32.object({ platform: SocialPlatformSchema, connected: z32.boolean().nullable() })),
-  page: MiniAppSlugSchema,
-  as_of: Timestamp,
-  timezone: z32.string().min(1),
-  spec: ResolvedPageSpecSchema
+// ../core/src/schema/ads.ts
+import { z as z33 } from "zod";
+var AdProviderSchema = z33.enum(["google"]);
+var AdCampaignStatusSchema = z33.enum(["enabled", "paused", "removed", "unknown"]);
+var AdCampaignSchema = z33.object({
+  id: z33.string().min(1),
+  object: z33.literal("ad_campaign"),
+  provider: AdProviderSchema,
+  connection_id: z33.string().min(1),
+  customer_id: z33.string().regex(/^\d{10}$/),
+  resource_name: z33.string().min(1),
+  name: z33.string().min(1),
+  type: z33.literal("search"),
+  status: AdCampaignStatusSchema,
+  /** Null for provider campaigns with no ad; list and status reads are campaign-based. */
+  final_url: z33.url().nullable(),
+  budget_micro_usd: MicroUsdField.nonnegative(),
+  start_date: z33.iso.date(),
+  end_date: z33.iso.date()
+});
+var AdCampaignInsightsSchema = z33.object({
+  object: z33.literal("ad_campaign_insights"),
+  provider: AdProviderSchema,
+  campaign_id: z33.string().min(1),
+  impressions: z33.number().int().nonnegative(),
+  clicks: z33.number().int().nonnegative(),
+  conversions: z33.number().nonnegative(),
+  spend_micro_usd: MicroUsdField.nonnegative()
 });
 
 // ../core/src/session-token.ts
@@ -3302,19 +3581,30 @@ var encoder = new TextEncoder();
 // ../core/src/logo-svg.ts
 var MAX_BYTES = 16 * 1024;
 
+// ../core/src/brand-kit.ts
+import { z as z34 } from "zod";
+var HARMONIES = [165, 40, 120, 200];
+var BRAND_HARMONIES = HARMONIES.length;
+var BrandKitArgsSchema = z34.object({
+  colour: z34.string().regex(/^#[0-9a-fA-F]{6}$/).describe("The brand's main colour, as #rrggbb \u2014 usually the logo's own. The palette is drawn around it."),
+  harmony: z34.number().int().min(0).max(BRAND_HARMONIES - 1).optional().describe("Which accent the palette takes, 0\u20133. Change it when asked for other colours with the same main one."),
+  typeface: z34.enum(BRAND_TYPEFACES).describe("grotesk (clean), serif (classic), rounded (friendly) or mono (technical)."),
+  tagline: z34.string().max(80).optional().describe("One short line under the name. Leave it out when there is none.")
+});
+
 // ../core/src/file-url.ts
 var encoder2 = new TextEncoder();
 var SESSION_FILE_URL_TTL_MS = 15 * 6e4;
 
 // src/define.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 
 // src/roster.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 
 // src/report.ts
 import { ApiError, send } from "@usenaive-sdk/vetta";
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 function message(error) {
   if (error instanceof ApiError && error.requestId !== "") return `${error.message} (request ${error.requestId})`;
   return error instanceof Error ? error.message : String(error);
@@ -3356,10 +3646,10 @@ async function absent(work) {
     throw error;
   }
 }
-var PageShape = z33.object({
-  data: z33.array(z33.unknown()),
-  has_more: z33.boolean(),
-  next_cursor: z33.string().nullable()
+var PageShape = z35.object({
+  data: z35.array(z35.unknown()),
+  has_more: z35.boolean(),
+  next_cursor: z35.string().nullable()
 });
 function rowLabel(row) {
   const { object, id } = row ?? {};
@@ -3391,17 +3681,17 @@ async function tombstone(name, current, remove, dryRun) {
 }
 
 // src/roster.ts
-var NAME = z34.string().min(1);
-var RosterNameSchema = z34.union([
+var NAME = z36.string().min(1);
+var RosterNameSchema = z36.union([
   NAME.transform((name) => ({ type: "agent", name })),
-  z34.object({ type: z34.literal("agent"), name: NAME, version: z34.number().int().positive().optional() }),
-  z34.object({ type: z34.literal("self") }),
-  z34.object({ type: z34.literal("advisor"), model: z34.string().min(1) })
+  z36.object({ type: z36.literal("agent"), name: NAME, version: z36.number().int().positive().optional() }),
+  z36.object({ type: z36.literal("self") }),
+  z36.object({ type: z36.literal("advisor"), model: z36.string().min(1) })
 ]);
-var DeclMultiagentField = z34.union([
-  z34.boolean(),
-  z34.object({ ...MultiagentSchema.shape, agents: z34.array(RosterNameSchema).min(1).max(20) }),
-  z34.null()
+var DeclMultiagentField = z36.union([
+  z36.boolean(),
+  z36.object({ ...MultiagentSchema.shape, agents: z36.array(RosterNameSchema).min(1).max(20) }),
+  z36.null()
 ]);
 var hasRoster = (value) => typeof value === "object" && value !== null;
 var rosterNames = (roster) => roster.agents.flatMap((entry) => entry.type === "agent" ? [entry.name] : []);
@@ -3450,114 +3740,75 @@ async function patchRoster(client, decl, roster, existing, ids, dryRun, lines) {
   updated();
 }
 
-// src/template.ts
-var BLUEPRINTS = {
-  /** Clients, pipeline, deliverables, calendar. */
-  agency: { templates: ["blank", "seo-geo"], default: "blank" },
-  /**
-   * Post queue, accounts, calendar, analytics. The wire ids are frozen: `install.template` is a
-   * stored string on every provisioned org, so the display names moved ("Naive Short Form v1",
-   * "Naive Long Form v1", "Naive Clipping v1") and these did not.
-   *
-   * The first three are the base crews. The six after them are NICHE CHANNEL TEMPLATES (ADR-1115,
-   * ADR-1119): each is a thin template that reuses a base crew (`gaming-clips`/`news`/`sports` on
-   * `clipping`; `ufc`/`history`/`animal-feast` on `faceless`) and pins `naive/channel-template-<niche>`
-   * in every seat's `skills[]`. They are ordinary templates of this blueprint, so they publish, install
-   * and switch through the exact paths the base three do — the whole point of a template being data.
-   */
-  media: { templates: ["faceless", "longform", "clipping", "gaming-clips", "news", "sports", "ufc", "history", "animal-feast"] },
-  /** Pages, posts, forms, analytics — a published site with a crew behind it (`usenaive/web-blueprint`). */
-  web: { templates: ["publisher"], default: "publisher" }
-};
-var list = (names) => names.join(", ");
-function chooseTemplate(blueprint, template) {
-  if (blueprint === void 0) {
-    if (template === void 0) return { ok: true, template: void 0 };
-    return {
-      ok: false,
-      message: `template "${template}" names no blueprint \u2014 a template belongs to one, so add \`blueprint: "\u2026"\` (${list(Object.keys(BLUEPRINTS))})`
-    };
-  }
-  const known = BLUEPRINTS[blueprint];
-  if (known === void 0) {
-    return { ok: false, message: `blueprint "${blueprint}" is not a blueprint \u2014 the blueprints are ${list(Object.keys(BLUEPRINTS))}` };
-  }
-  if (template === void 0) {
-    if (known.default !== void 0) return { ok: true, template: known.default };
-    return {
-      ok: false,
-      message: `blueprint "${blueprint}" needs a template \u2014 choose one of ${list(known.templates)}. Its crews spend money in different ways, so there is no default to fall back to.`
-    };
-  }
-  if (!known.templates.includes(template)) {
-    return { ok: false, message: `template "${template}" is not a template of blueprint "${blueprint}" \u2014 its templates are ${list(known.templates)}` };
-  }
-  return { ok: true, template };
-}
-
 // src/define.ts
 var BlueprintRefusal = class extends Error {
   name = "BlueprintRefusal";
 };
-var EnvValueSchema = z35.union([
-  z35.string(),
-  z35.object({ from_env: z35.string().min(1) }),
-  z35.object({ generate: z35.literal(true) })
+var EnvValueSchema = z37.union([
+  z37.string(),
+  z37.object({ from_env: z37.string().min(1) }),
+  z37.object({ generate: z37.literal(true) })
 ]);
-var AppDeclSchema = z35.object({
+var AppDeclSchema = z37.object({
   /** Becomes a hostname, so the grammar is the platform's `APP_NAME` (a DNS label). */
-  name: z35.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
+  name: z37.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
   type: AppTypeSchema,
-  description: z35.string().optional(),
+  description: z37.string().optional(),
   /** A directory whose files are collected and shipped as the app's file-map deployment. */
-  deploy_dir: z35.string().min(1).optional(),
+  deploy_dir: z37.string().min(1).optional(),
   /** The path the app itself serves MCP on (§29.5); `fullstack` only. Absent means none. */
   mcp: AppMcpPathSchema.optional(),
   /** Written as the app's write-only secrets (§29.2) on every apply; names follow the platform's `ENV_NAME`. */
-  env: z35.record(z35.string().regex(ENV_NAME), EnvValueSchema, { error: "keyed by environment variable name (A-Z, 0-9, _)" }).optional(),
+  env: z37.record(z37.string().regex(ENV_NAME), EnvValueSchema, { error: "keyed by environment variable name (A-Z, 0-9, _)" }).optional(),
   /** An install may not leave this app out of its `selection` (§31.2). Absent means it may. */
-  required: z35.boolean().optional(),
+  required: z37.boolean().optional(),
   // core-gaps: U8-database
   /** SQL files applied in order to the app's database after it is provisioned (§37); `fullstack` only. */
-  migrations: z35.array(z35.string().min(1)).optional(),
+  migrations: z37.array(z37.string().min(1)).optional(),
   // core-gaps: storage-stock
   /** Buckets the app's object store must hold (§38.2); `fullstack` only. `public` defaults to false. */
-  buckets: z35.array(CreateBucketSchema).optional()
+  buckets: z37.array(CreateBucketSchema).optional()
 });
-var ScheduleDeclSchema = z35.object({
-  cron: z35.string().min(1),
-  timezone: z35.string().min(1).optional(),
+var ScheduleDeclSchema = z37.object({
+  cron: z37.string().min(1),
+  timezone: z37.string().min(1).optional(),
   /** The message every fire opens its session with (`input_template` on the wire). */
-  input: z35.string().min(1),
+  input: z37.string().min(1),
+  /**
+   * What a fire does, in a few words a person reads ("Weekly report") — the launch card's line for it
+   * and the receipt's (`canonical-spec §31.3`, ADR-1172). Printed, never provisioned; absent, the
+   * platform reads the opening of `input`.
+   */
+  summary: z37.string().min(1).max(48).optional(),
   budget_micro_usd: MicroUsdField.nonnegative(),
-  identity: z35.string().min(1).optional(),
-  enabled: z35.boolean().optional()
+  identity: z37.string().min(1).optional(),
+  enabled: z37.boolean().optional()
 });
 var ToolsDeclSchema = ToolsetSchema;
-var AgentDeclSchema = z35.object({
-  name: z35.string().min(1),
-  model: z35.string().min(1),
+var AgentDeclSchema = z37.object({
+  name: z37.string().min(1),
+  model: z37.string().min(1),
   budget: BudgetSchema,
-  description: z35.string().optional(),
+  description: z37.string().optional(),
   /** Two or three words the studio prints beside the name (§31.5) — "Head of content", not a sentence. */
-  role: z35.string().min(1).optional(),
+  role: z37.string().min(1).optional(),
   /** An install may not leave this agent out of its `selection` (§31.2). Absent means it may. */
-  required: z35.boolean().optional(),
-  system: z35.string().optional(),
+  required: z37.boolean().optional(),
+  system: z37.string().optional(),
   tools: ToolsDeclSchema.optional(),
-  skills: z35.array(SkillRefSchema).optional(),
-  mcp_servers: z35.array(McpServerSchema).optional(),
+  skills: z37.array(SkillRefSchema).optional(),
+  mcp_servers: z37.array(McpServerSchema).optional(),
   /** The rest of the runtime's agent config (§31.6), each the core schema; absent means the route's default and never drift. */
   window: WindowSchema.optional(),
   /** A roster names crew members by declared *name*; `up` resolves them to `agt_` ids in a second pass (`roster.ts`). */
   multiagent: DeclMultiagentField.optional(),
   output_schema: JsonSchemaDocument.nullable().optional(),
-  structured_output_required: z35.boolean().optional(),
+  structured_output_required: z37.boolean().optional(),
   metadata: Metadata.optional(),
   /** Declared app *names*; `up` resolves them to `app_` ids in `tools.configs.apps` (§29.3). */
-  allowed_apps: z35.array(z35.string()).optional(),
+  allowed_apps: z37.array(z37.string()).optional(),
   /** A declared identity *name*; `up` attaches it after the agent upsert (§22). */
-  identity: z35.string().min(1).optional(),
+  identity: z37.string().min(1).optional(),
   /**
    * Who this agent may `send_to_agent` (§31.7, §28.12): `true` (anyone in the organization),
    * `false` (nobody), `"team"` (its `multiagent` roster), or declared agent *names*, checked
@@ -3565,7 +3816,7 @@ var AgentDeclSchema = z35.object({
    */
   handoffs: HandoffsField.optional(),
   /** The agent's deployments as a complete set: declared → owned, and the rest are pruned (ADR-0355). */
-  schedules: z35.array(ScheduleDeclSchema).optional(),
+  schedules: z37.array(ScheduleDeclSchema).optional(),
   /**
    * The first thing this agent reads, once, on the apply that **creates** it (`canonical-spec
    * §31.4`). It is what turns a provisioned crew into a crew that has started working.
@@ -3578,73 +3829,86 @@ var AgentDeclSchema = z35.object({
    * repeatedly and unattended while an intake spends once, at an apply a person is watching. Absent
    * means the agent's own `budget` governs.
    */
-  intake: z35.object({ message: z35.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
+  intake: z37.object({ message: z37.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
 });
-var CredentialDeclSchema = z35.object({
+var CredentialDeclSchema = z37.object({
   kind: VaultCredentialKindSchema,
-  key: z35.string().min(1).max(128),
+  key: z37.string().min(1).max(128),
   /** The one exact destination host an `env_var` is bound to. */
-  host: z35.string().min(1).optional(),
+  host: z37.string().min(1).optional(),
   /** The MCP server URL a `static_bearer` / `mcp_oauth` token is matched to. */
-  mcp_server_url: z35.url().optional(),
-  value: z35.object({ from_env: z35.string().min(1) })
+  mcp_server_url: z37.url().optional(),
+  value: z37.object({ from_env: z37.string().min(1) })
 });
-var VaultDeclSchema = z35.object({
+var VaultDeclSchema = z37.object({
   name: VaultSchema.shape.display_name,
-  identity: z35.string().min(1).optional(),
-  credentials: z35.array(CredentialDeclSchema)
+  identity: z37.string().min(1).optional(),
+  credentials: z37.array(CredentialDeclSchema)
 });
-var SkillDeclSchema = z35.object({
-  slug: z35.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  file: z35.string().min(1)
+var SkillDeclSchema = z37.object({
+  slug: z37.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
+  file: z37.string().min(1)
 });
 var LegalDeclSchema = CreateLegalCompanySchema.pick({
   state: true,
   name_options: true,
   naics_code: true,
   description: true
-}).extend({ label: z35.string().min(1).max(128) });
+}).extend({ label: z37.string().min(1).max(128) });
 var WalletDeclSchema = CreateWalletSchema.or(
-  z35.array(CreateWalletSchema).refine(
-    (list2) => new Set(list2.map((w) => w.network ?? DEFAULT_WALLET_NETWORK)).size === list2.length,
+  z37.array(CreateWalletSchema).refine(
+    (list) => new Set(list.map((w) => w.network ?? DEFAULT_WALLET_NETWORK)).size === list.length,
     { message: "one wallet per network" }
   )
 );
 var CardDeclSchema = IssueCardSchema;
 var IdentityDeclSchema = IdentitySchema.pick({ name: true, description: true }).partial({ description: true }).extend({
-  legal: z35.array(LegalDeclSchema).optional(),
+  legal: z37.array(LegalDeclSchema).optional(),
   wallet: WalletDeclSchema.optional(),
-  cards: z35.array(CardDeclSchema).optional()
-});
-var RemovedSchema = z35.object({
-  apps: z35.array(z35.string().min(1)).default([]),
-  agents: z35.array(z35.string().min(1)).default([]),
-  skills: z35.array(z35.string().min(1)).default([]),
-  identities: z35.array(z35.string().min(1)).default([]),
-  vaults: z35.array(z35.string().min(1)).default([])
-});
-var KeptSchema = z35.object({ agents: z35.array(z35.string().min(1)).default([]) });
-var TaskDeclSchema = z35.object({
-  key: z35.string().min(1),
-  title: z35.string().min(1).max(200),
-  body: z35.string().max(8192).optional(),
-  assignee: z35.string().min(1).optional(),
-  blocked_by: z35.array(z35.string().min(1)).optional()
-});
-var ProjectSchema = z35.object({
-  name: z35.string().min(1),
+  cards: z37.array(CardDeclSchema).optional()
+});
+var RemovedSchema = z37.object({
+  apps: z37.array(z37.string().min(1)).default([]),
+  agents: z37.array(z37.string().min(1)).default([]),
+  skills: z37.array(z37.string().min(1)).default([]),
+  identities: z37.array(z37.string().min(1)).default([]),
+  vaults: z37.array(z37.string().min(1)).default([])
+});
+var KeptSchema = z37.object({ agents: z37.array(z37.string().min(1)).default([]) });
+var TaskDeclSchema = z37.object({
+  key: z37.string().min(1),
+  title: z37.string().min(1).max(200),
+  body: z37.string().max(8192).optional(),
+  assignee: z37.string().min(1).optional(),
+  blocked_by: z37.array(z37.string().min(1)).optional()
+});
+var ProjectSchema = z37.object({
+  name: z37.string().min(1),
   /** The machine this project runs: its repo, its screens, its `/api/*` (`template.ts`). */
-  blueprint: z35.string().min(1).optional(),
+  blueprint: z37.string().min(1).optional(),
   /** Which of that blueprint's templates provides the crew; a blueprint with a default may omit it. */
-  template: z35.string().min(1).optional(),
+  template: z37.string().min(1).optional(),
   /**
    * What a person calls this template, one line on what its crew does, and the networks it
    * publishes to (`canonical-spec §31.5`). Printed on the artifact and never provisioned: where the
    * crew posts is the accounts connected to its persona, not this list.
    */
-  title: z35.string().min(1).max(80).optional(),
-  description: z35.string().min(1).max(280).optional(),
-  platforms: z35.array(SocialPlatformSchema).optional(),
+  title: z37.string().min(1).max(80).optional(),
+  description: z37.string().min(1).max(280).optional(),
+  platforms: z37.array(SocialPlatformSchema).optional(),
+  /**
+   * The first week in the template's own words, for the launch card (`canonical-spec §31.5`,
+   * ADR-1172): `day_one` is what Day 1 comes to ("Set up and publish the first post"), `every_day`
+   * what each day after it carries ("New posts · Performance analysis"), and `after` what the card's
+   * "Day 8 on" line says follows the week ("The week repeats · the CEO finds sponsors…"). Printed,
+   * never provisioned; absent, the card reads the seeded cards and the timers, and "Day 8 on" says
+   * only "The week repeats".
+   */
+  roadmap: z37.object({
+    day_one: z37.string().min(1).max(60).optional(),
+    every_day: z37.string().min(1).max(60).optional(),
+    after: z37.string().min(1).max(80).optional()
+  }).optional(),
   /**
    * The company's mini apps (`canonical-spec §50`): each a name, an icon and pages of the platform's
    * blocks — data only, checked with the platform's catalog here and again when a page is read. The
@@ -3662,21 +3926,21 @@ var ProjectSchema = z35.object({
    *
    * **Configuration only.** A secret is a vault credential or an app secret; neither is an answer.
    */
-  questions: z35.array(QuestionFieldSchema).default([]),
-  skills: z35.array(SkillDeclSchema).default([]),
-  identities: z35.array(IdentityDeclSchema).default([]),
-  vaults: z35.array(VaultDeclSchema).default([]),
-  apps: z35.array(AppDeclSchema).default([]),
-  agents: z35.array(AgentDeclSchema).default([]),
+  questions: z37.array(QuestionFieldSchema).default([]),
+  skills: z37.array(SkillDeclSchema).default([]),
+  identities: z37.array(IdentityDeclSchema).default([]),
+  vaults: z37.array(VaultDeclSchema).default([]),
+  apps: z37.array(AppDeclSchema).default([]),
+  agents: z37.array(AgentDeclSchema).default([]),
   /**
    * The agents this template creates PER CLIENT the operator signs (`canonical-spec §31.1`) —
    * printed on the artifact so a person sees the whole company, never provisioned by an apply,
    * because the apply does not know the clients yet. Names only: a model and a budget are the
    * crew's business at the moment a client is signed, not the declaration's.
    */
-  crew_per_client: z35.array(z35.object({ name: z35.string().min(1), role: z35.string().min(1).optional(), description: z35.string().optional() })).optional(),
+  crew_per_client: z37.array(z37.object({ name: z37.string().min(1), role: z37.string().min(1).optional(), description: z37.string().optional() })).optional(),
   /** The crew's first work, as cards on the organization's board rather than N private intakes (§31.11). */
-  tasks: z35.array(TaskDeclSchema).default([]),
+  tasks: z37.array(TaskDeclSchema).default([]),
   removed: RemovedSchema.default({ apps: [], agents: [], skills: [], identities: [], vaults: [] }),
   kept: KeptSchema.default({ agents: [] })
 });
@@ -4419,7 +4683,7 @@ async function reconcileSchedules(client, agent, declared, live, identityIds, dr
       // `<agent> @ <cron>` says WHEN a timer runs and nothing about what it does, so the dashboard's
       // opening message could only ever draw a timetable from these lines. The brief's first
       // sentence is what turns that timetable into a roadmap (§29.6).
-      summary: brief(decl.input)
+      summary: decl.summary ?? brief(decl.input)
     }))
   );
   if (agent.action === "refused") return;
@@ -4530,6 +4794,7 @@ async function reportLegal(client, decls, identityId, skipped) {
 }
 
 // src/tasks.ts
+import { ApiError as ApiError2 } from "@usenaive-sdk/vetta";
 var ORCHESTRATOR_MARKER = "orchestrator";
 var CEO_LABEL = "CEO";
 var CEO_DETAIL = "Hires and directs the crew";
@@ -4561,7 +4826,13 @@ async function ensureOrchestrator(client, existing, members, dryRun) {
     return { name: CEO_LABEL, action: "created", id: made.id };
   }
   if (live !== null && !changed(team, live)) return { name: current.name, action: "unchanged", id: current.id };
-  if (!dryRun) await client.agents.update(current.id, { multiagent: team });
+  if (dryRun) return { name: current.name, action: "updated", id: current.id };
+  try {
+    await client.agents.update(current.id, { multiagent: team });
+  } catch (error) {
+    if (!(error instanceof ApiError2 && error.status === 403)) throw error;
+    return { name: current.name, action: "unchanged", id: current.id, reason: `crew not seated on its roster: ${error.message} (request ${error.requestId})` };
+  }
   return { name: current.name, action: "updated", id: current.id };
 }
 async function seedTasks(client, config, existing, agents, dryRun, into, skipped) {