@usenaive-sdk/blueprints 0.8.0 → 0.10.0

package/dist/index.js

@@ -3,9 +3,9 @@ var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
 var SUFFIX_LENGTH = 26;
 var SUFFIX_PATTERN = new RegExp(`^[${ALPHABET}]{${SUFFIX_LENGTH},}$`);
 function isId(prefix, value) {
-  const head = `${prefix}_`;
-  if (!value.startsWith(head)) return false;
-  return SUFFIX_PATTERN.test(value.slice(head.length).toLowerCase());
+  const head2 = `${prefix}_`;
+  if (!value.startsWith(head2)) return false;
+  return SUFFIX_PATTERN.test(value.slice(head2.length).toLowerCase());
 }
 
 // ../core/src/errors.ts
@@ -15,6 +15,8 @@ var CODES = {
   unauthorized: ["authentication", 401],
   forbidden: ["permission", 403],
   not_found: ["not_found", 404],
+  /** The path exists; the method does not. The response carries `Allow` (§3). */
+  method_not_allowed: ["invalid_request", 405],
   budget_exceeded: ["quota", 402],
   insufficient_credits: ["quota", 402],
   /**
@@ -114,10 +116,6 @@ function decimalStringFromMicro(amount) {
   return `${amount < 0 ? "-" : ""}${absolute / BigInt(USD)}.${fraction}`;
 }
 
-// ../core/src/session-token.ts
-var SESSION_TTL_SECONDS = 30 * 24 * 60 * 60;
-var encoder = new TextEncoder();
-
 // ../core/src/schema/audit-actions.ts
 var AUDIT_ACTIONS_SHIPPED = [
   "agent.updated",
@@ -143,6 +141,8 @@ var AUDIT_ACTIONS_P1 = [
   "computer.resumed",
   "computer.snapshot_created",
   "computer.updated",
+  "computer.taken_over",
+  "computer.handed_back",
   "browser.live_view_opened",
   "deployment.created",
   "deployment.updated",
@@ -181,6 +181,8 @@ var AUDIT_ACTIONS_P2 = [
   "connection.auth_config_created",
   "connection.auth_config_deleted",
   "domain.created",
+  "domain.purchased",
+  "domain.purchase_refunded",
   "domain.verified",
   "domain.deleted",
   "email.created",
@@ -278,7 +280,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"];
+var TOOL_TIERS = ["search", "media", "social", "browser", "storage", "email"];
 var LINE_ITEM_TIERS = [...TOKEN_TIERS, "computer", ...TOOL_TIERS];
 var LineItemTierSchema = z.enum(LINE_ITEM_TIERS);
 var TokenUsageSchema = z.object({
@@ -308,11 +310,41 @@ import { z as z4 } from "zod";
 
 // ../core/src/schema/org.ts
 import { z as z3 } from "zod";
+var DEFAULT_ORG_TIMEZONE = "America/New_York";
+function canonicalZone(name) {
+  if (!name.includes("/") && name !== "UTC") return void 0;
+  try {
+    const zone = new Intl.DateTimeFormat("en-US", { timeZone: name }).resolvedOptions().timeZone;
+    return zone === "UTC" || Intl.supportedValuesOf("timeZone").includes(zone) ? zone : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var TimezoneSchema = z3.string().transform((name, ctx) => {
+  const zone = canonicalZone(name);
+  if (zone === void 0) {
+    ctx.addIssue({ code: "custom", message: "not a timezone; use an IANA name such as America/Los_Angeles" });
+    return z3.NEVER;
+  }
+  return zone;
+});
 var OrganizationSchema = z3.object({
   id: idOf("org"),
   object: z3.literal("organization"),
   name: z3.string(),
   balance_micro_usd: MicroUsdField,
+  /**
+   * The company's timezone, an IANA name (`America/New_York`, §20.6). Times the company chooses or
+   * reads are in it: a new routine's zone, when a post goes out. `America/New_York` until changed.
+   * Defaulted so a reply from a control plane older than 0088 (or a rolled-back Worker) still parses
+   * in a newer SDK/CLI rather than throwing on every `orgs.get/list/update`.
+   */
+  timezone: z3.string().min(1).default(DEFAULT_ORG_TIMEZONE),
+  /**
+   * The company's logo, an SVG a person or an agent drew (§20.7), passed by `checkLogoSvg`. `null`
+   * until one is set. Defaulted so a reply from a control plane older than 0093 still parses.
+   */
+  logo_svg: z3.string().nullable().default(null),
   created_at: Timestamp
 });
 var RoleSchema = z3.enum(["owner", "admin", "member"]);
@@ -664,7 +696,7 @@ function normaliseMultiagent(value) {
 }
 var HandoffsField = z6.union([z6.boolean(), z6.literal("team"), z6.array(z6.string().min(1)).max(50)]);
 var handoffsOf = (config) => config.handoffs ?? true;
-var handoffsEnabled = (handoffs) => handoffs === true || handoffs === "team" || handoffs !== false && handoffs.length > 0;
+var handoffsEnabled = (handoffs) => handoffs !== false;
 var agentConfigShape = {
   model: z6.string(),
   window: WindowSchema,
@@ -701,8 +733,131 @@ var AgentSchema = z6.object({
 });
 
 // ../core/src/schema/session.ts
+import { z as z8 } from "zod";
+
+// ../core/src/schema/social.ts
 import { z as z7 } from "zod";
-var SessionStatusSchema = z7.enum([
+var SOCIAL_PLATFORMS = [
+  "bluesky",
+  "facebook",
+  "instagram",
+  "linkedin",
+  "mastodon",
+  "pinterest",
+  "reddit",
+  "threads",
+  "tiktok",
+  "x",
+  "youtube"
+];
+var SOCIAL_APPS = /* @__PURE__ */ new Set([...SOCIAL_PLATFORMS, "twitter"]);
+var SOCIAL_TEXT_PLATFORMS = [
+  "bluesky",
+  "facebook",
+  "linkedin",
+  "mastodon",
+  "threads",
+  "x"
+];
+var SOCIAL_MEDIA_PLATFORMS = ["instagram", "tiktok", "youtube"];
+var SOCIAL_VISIBILITIES = ["public", "unlisted", "private"];
+var SOCIAL_VISIBILITY_PLATFORMS = ["mastodon", "youtube"];
+var SocialVisibilitySchema = z7.enum(SOCIAL_VISIBILITIES);
+var SOCIAL_VISIBILITY_RULE = `visibility is ${SOCIAL_VISIBILITIES.join(", ")} and only ${SOCIAL_VISIBILITY_PLATFORMS.join(" and ")} accept it; omit it and the post publishes at the account's own default, which on a video channel is normally public`;
+var SocialPlatformSchema = z7.enum(SOCIAL_PLATFORMS);
+var SocialTextPlatformSchema = z7.enum(SOCIAL_TEXT_PLATFORMS);
+var isText = (platform) => SOCIAL_TEXT_PLATFORMS.includes(platform);
+var isMedia = (platform) => SOCIAL_MEDIA_PLATFORMS.includes(platform);
+var SOCIAL_PLATFORM_RULE = `${SOCIAL_TEXT_PLATFORMS.join(", ")} take a text-only post; ${SOCIAL_MEDIA_PLATFORMS.join(", ")} may be named only when the post carries media_urls or file_ids; ${SOCIAL_PLATFORMS.filter((platform) => !isText(platform) && !isMedia(platform)).join(", ")} cannot be posted to`;
+var SocialAccountSchema = z7.object({
+  id: z7.string().min(1),
+  object: z7.literal("social_account"),
+  identity_id: idOf("idn"),
+  platform: SocialPlatformSchema,
+  username: z7.string().nullable(),
+  display_name: z7.string().nullable(),
+  avatar_url: z7.url().nullable(),
+  connected_at: Timestamp.nullable()
+});
+var SocialPostStatusSchema = z7.enum([
+  "draft",
+  "scheduled",
+  "processing",
+  "posted",
+  "failed",
+  "deleted"
+]);
+var SocialPostSchema = z7.object({
+  id: z7.string().min(1),
+  object: z7.literal("social_post"),
+  identity_id: idOf("idn"),
+  title: z7.string(),
+  platforms: z7.array(SocialPlatformSchema),
+  status: SocialPostStatusSchema,
+  scheduled_at: Timestamp.nullable(),
+  posted_at: Timestamp.nullable(),
+  error: z7.string().nullable()
+});
+var SocialUploadSchema = z7.object({
+  id: z7.string().min(1),
+  object: z7.literal("social_upload"),
+  identity_id: idOf("idn"),
+  type: z7.enum(["image", "video", "document"]),
+  url: z7.url().nullable()
+});
+var SocialAnalyticsSchema = z7.object({
+  object: z7.literal("social_analytics"),
+  identity_id: idOf("idn"),
+  resource_id: z7.string().min(1),
+  platform: SocialPlatformSchema.nullable(),
+  data: z7.unknown()
+});
+var SocialCommentSchema = z7.object({
+  id: z7.string().min(1),
+  object: z7.literal("social_comment"),
+  identity_id: idOf("idn"),
+  post_id: z7.string().min(1),
+  platforms: z7.array(SocialPlatformSchema),
+  status: SocialPostStatusSchema,
+  posted_at: Timestamp.nullable(),
+  data: z7.unknown()
+});
+var POST_STATUSES = ["pending", "scheduled", "posted", "failed"];
+var PostStatusSchema = z7.enum(POST_STATUSES);
+var PostSchema = z7.object({
+  object: z7.literal("post"),
+  id: z7.string().min(1),
+  status: PostStatusSchema,
+  identity_id: z7.string().nullable(),
+  agent_id: z7.string().nullable(),
+  session_id: z7.string().nullable(),
+  tool_call_id: z7.string().nullable(),
+  content: z7.string().nullable(),
+  platforms: z7.array(z7.string()),
+  file_ids: z7.array(z7.string()),
+  media_urls: z7.array(z7.string()),
+  visibility: SocialVisibilitySchema.nullable(),
+  scheduled_at: Timestamp.nullable(),
+  posted_at: Timestamp.nullable(),
+  url: z7.string().nullable(),
+  error: z7.string().nullable(),
+  /** The latest stored reading, `{metric: value}`; `null` before `social.post_metrics` read any. */
+  metrics: z7.record(z7.string(), z7.number()).nullable(),
+  measured_at: Timestamp.nullable(),
+  /** Pending only: the earlier post this call would repeat — same identity, network and file. */
+  duplicate_of: z7.object({
+    id: z7.string(),
+    status: PostStatusSchema,
+    platform: z7.string(),
+    at: Timestamp.nullable(),
+    agent_id: z7.string().nullable(),
+    session_id: z7.string().nullable()
+  }).nullable(),
+  created_at: Timestamp
+});
+
+// ../core/src/schema/session.ts
+var SessionStatusSchema = z8.enum([
   "queued",
   "running",
   "idle",
@@ -710,7 +865,23 @@ var SessionStatusSchema = z7.enum([
   "failed",
   "cancelled"
 ]);
-var StopReasonSchema = z7.enum([
+var SessionModeSchema = z8.enum(["plan", "build"]);
+var PLAN_MAX_CHARS = 2e4;
+var PlanSchema = z8.object({
+  object: z8.literal("plan"),
+  markdown: z8.string().max(PLAN_MAX_CHARS),
+  version: z8.number().int().nonnegative(),
+  by: z8.enum(["agent", "owner"]).nullable()
+});
+var PlanWriteSchema = z8.object({
+  markdown: z8.string().max(PLAN_MAX_CHARS),
+  base_version: z8.number().int().nonnegative()
+});
+var ProposePlanSchema = z8.object({
+  version: z8.number().int().positive(),
+  spends_or_publishes: z8.array(z8.string().min(1).max(200)).max(10).optional()
+});
+var StopReasonSchema = z8.enum([
   "end_turn",
   "awaiting_input",
   "awaiting_approval",
@@ -736,27 +907,27 @@ var StopReasonSchema = z7.enum([
    */
   "awaiting_answer"
 ]);
-var ThreadRoleSchema = z7.enum(["coordinator", "member"]);
-var MessageSchema = z7.object({
-  role: z7.enum(["system", "user", "assistant", "tool"]),
-  content: z7.string(),
-  tool_call_id: z7.string().optional()
+var ThreadRoleSchema = z8.enum(["coordinator", "member"]);
+var MessageSchema = z8.object({
+  role: z8.enum(["system", "user", "assistant", "tool"]),
+  content: z8.string(),
+  tool_call_id: z8.string().optional()
 });
-var ToolImageSchema = z7.object({
+var ToolImageSchema = z8.object({
   file_id: idOf("fil"),
-  url: z7.string().url().describe("A short-lived signed read for the file's bytes."),
-  media_type: z7.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
+  url: z8.string().url().describe("A short-lived signed read for the file's bytes."),
+  media_type: z8.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
 });
-var ToolResultSchema = z7.object({
-  output: z7.unknown(),
-  is_error: z7.boolean().optional(),
-  content: z7.string().optional(),
-  images: z7.array(ToolImageSchema).max(12).optional()
+var ToolResultSchema = z8.object({
+  output: z8.unknown(),
+  is_error: z8.boolean().optional(),
+  content: z8.string().optional(),
+  images: z8.array(ToolImageSchema).max(12).optional()
 });
 var QuestionFieldBase = {
-  key: z7.string().min(1).max(64),
-  label: z7.string().min(1).max(200),
-  help: z7.string().max(500).optional(),
+  key: z8.string().min(1).max(64),
+  label: z8.string().min(1).max(200),
+  help: z8.string().max(500).optional(),
   /**
    * A field that may be left blank, and it defaults to **false** — the rule "every field must be
    * answered" (`assertAnswers`) is still the rule, and this is the one documented way out of it.
@@ -776,60 +947,112 @@ var QuestionFieldBase = {
    * required on the OUTPUT type — so every hand-written `QuestionField` in the codebase, and every
    * one written after it, would have to spell out the flag it does not use.
    */
-  optional: z7.boolean().optional()
+  optional: z8.boolean().optional()
 };
-var QuestionFieldSchema = z7.discriminatedUnion("type", [
-  z7.object({
+var QuestionFieldSchema = z8.discriminatedUnion("type", [
+  z8.object({
     ...QuestionFieldBase,
-    type: z7.literal("text"),
-    placeholder: z7.string().max(200).optional()
+    type: z8.literal("text"),
+    placeholder: z8.string().max(200).optional()
   }),
-  z7.object({
+  z8.object({
     ...QuestionFieldBase,
-    type: z7.literal("choice"),
+    type: z8.literal("choice"),
     /**
      * Plain strings: the option is both the value and the label, because the answer is read back by
      * a model, which wants the words and not an id. Fewer than two is not a choice, and more than
      * twelve is a list — which belongs in the prompt.
      */
-    options: z7.array(z7.string().min(1).max(200)).min(2).max(12),
-    multiple: z7.boolean().default(false),
+    options: z8.array(z8.string().min(1).max(200)).min(2).max(12),
+    multiple: z8.boolean().default(false),
     /**
      * The free-text escape, and it defaults to **true** on purpose: the agent wrote the options and
      * the agent is the one that does not know the answer, so an operator must always be able to say
      * something it did not think of. A question that truly admits only its list opts out explicitly.
      */
-    other: z7.boolean().default(true)
+    other: z8.boolean().default(true),
+    /**
+     * A PICTURE OR A LINE FOR AN OPTION (ADR-1103): a template's "how it looks" shows its looks, and
+     * a niche says what it means in one line. Each names its option by its words; one naming no
+     * option is ignored, never refused. With a picture on any option the dashboard draws the choice
+     * as a grid of pictures. `image` is `https://`, or a path on the dashboard itself. An array
+     * and not a map, because a model's tool schema cannot always take a map. An older reader drops
+     * it and draws the plain list.
+     */
+    details: z8.array(
+      z8.object({
+        option: z8.string().min(1).max(200),
+        note: z8.string().min(1).max(120).optional(),
+        image: z8.string().max(500).regex(/^\/(?!\/)/, "an image is a path on the dashboard").optional()
+      })
+    ).max(12).optional()
+  }),
+  /**
+   * THE PERSON'S OWN MEDIA (ADR-1103): "show us what you like". The dashboard offers an upload for
+   * images or a video, which land in the organization's files, and a box for a link. The answer is
+   * the list: `fil_` ids and `https://` links, which an agent opens with `files_get`, `view_image`
+   * or the browser. `placeholder` is the link box's.
+   */
+  z8.object({
+    ...QuestionFieldBase,
+    type: z8.literal("media"),
+    placeholder: z8.string().max(200).optional()
   })
 ]);
-var QuestionSchema = z7.object({
-  prompt: z7.string().min(1).max(1e3),
-  fields: z7.array(QuestionFieldSchema).min(1).max(3)
-});
-var AnswersSchema = z7.record(
-  z7.string().min(1).max(64),
-  z7.union([z7.string().max(2e3), z7.array(z7.string().max(2e3)).min(1).max(12)])
-).refine((answers) => Object.keys(answers).length <= 3, {
-  message: "a question has at most 3 fields, so an answer has at most 3 keys"
-});
-var PendingActionSchema = z7.object({
-  kind: z7.enum(["tool", "question"]).default("tool"),
-  tool_call_id: z7.string(),
-  name: z7.string(),
-  args: z7.record(z7.string(), z7.unknown()),
+var ConnectFieldSchema = z8.object({
+  ...QuestionFieldBase,
+  type: z8.literal("connect"),
+  platforms: z8.array(SocialPlatformSchema).min(1).max(6)
+});
+var AskFieldSchema = z8.discriminatedUnion("type", [...QuestionFieldSchema.options, ConnectFieldSchema]);
+var QUESTION_FIELDS_MAX = 3;
+var QuestionSchema = z8.object({
+  prompt: z8.string().min(1).max(1e3),
+  fields: z8.array(AskFieldSchema).min(1).max(QUESTION_FIELDS_MAX, {
+    message: `a question has at most ${QUESTION_FIELDS_MAX} fields \u2014 ask the rest in a second question once these are answered`
+  })
+}).refine((question) => question.fields.length === 1 || question.fields.every((field) => field.type !== "connect"), {
+  // A connect card answers itself when the accounts land (ADR-1102); a field beside it would need
+  // a Send the card does not have.
+  message: "a connect field is a question of its own: ask anything else in a separate question",
+  path: ["fields"]
+});
+var answersOf = (max, message3) => z8.record(
+  z8.string().min(1).max(64),
+  z8.union([z8.string().max(2e3), z8.array(z8.string().max(2e3)).min(1).max(12)])
+).refine((answers) => Object.keys(answers).length <= max, { message: message3 });
+var AnswersSchema = answersOf(
+  QUESTION_FIELDS_MAX,
+  `a question has at most ${QUESTION_FIELDS_MAX} fields, so an answer has at most ${QUESTION_FIELDS_MAX} keys`
+);
+var TEMPLATE_QUESTIONS_MAX = 4;
+var InstallAnswersSchema = answersOf(
+  TEMPLATE_QUESTIONS_MAX,
+  `a template asks at most ${TEMPLATE_QUESTIONS_MAX} questions, so an install has at most ${TEMPLATE_QUESTIONS_MAX} answers`
+);
+var PendingActionSchema = z8.object({
+  kind: z8.enum(["tool", "question"]).default("tool"),
+  tool_call_id: z8.string(),
+  name: z8.string(),
+  args: z8.record(z8.string(), z8.unknown()),
   /**
    * Present iff `kind` is `"question"`, and it is the parse of `args` rather than a second source
    * of truth: `args` is what the model called and therefore what replays byte-identically, while
    * `question` is what a renderer reads without having to know that `ask_operator`'s arguments
    * happen to be the question. Same content, two jobs.
    */
-  question: QuestionSchema.optional()
+  question: QuestionSchema.optional(),
+  /**
+   * The helper's thread a coordinator adopted this call from (§28, B-3; ADR-1101): the dashboard
+   * marks that helper as waiting on you. Absent on the session's own calls.
+   */
+  thread_id: idOf("ses").optional()
 });
-var SessionSchema = z7.object({
+var SessionSchema = z8.object({
   id: idOf("ses"),
-  object: z7.literal("session"),
+  object: z8.literal("session"),
   agent_id: idOf("agt"),
-  agent_version: z7.number().int().positive(),
+  agent_version: z8.number().int().positive(),
   deployment_id: idOf("dep").nullable(),
   /**
    * The persona this session acts as (`canonical-spec §22`). Chosen per task from the personas the
@@ -852,50 +1075,73 @@ var SessionSchema = z7.object({
   parent_session_id: idOf("ses").nullable(),
   root_session_id: idOf("ses").nullable(),
   thread_role: ThreadRoleSchema.nullable(),
+  /**
+   * The model the latest send picked (§7 `model`), or `null` when none has and the session runs its
+   * pinned version's model (§10, ADR-0832). Defaulted so a reply from an older control plane parses.
+   */
+  model: z8.string().nullable().default(null),
+  /** Plan mode (§7.5, §10): defaulted so a reply from an older control plane parses as `build`. */
+  mode: SessionModeSchema.default("build"),
   status: SessionStatusSchema,
   stop_reason: StopReasonSchema.nullable(),
   window: WindowSchema,
   budget_micro_usd: MicroUsdField.nonnegative(),
   consumed_micro_usd: MicroUsdField.nonnegative(),
   token_usage: TokenUsageSchema,
-  pending_actions: z7.array(PendingActionSchema),
+  pending_actions: z8.array(PendingActionSchema),
   output_schema: JsonSchemaDocument.nullable(),
-  structured_output: z7.record(z7.string(), z7.unknown()).nullable(),
-  last_seq: z7.number().int().nonnegative(),
+  structured_output: z8.record(z8.string(), z8.unknown()).nullable(),
+  last_seq: z8.number().int().nonnegative(),
   metadata: Metadata,
   started_at: Timestamp.nullable(),
   ended_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var SendMessageSchema = z7.object({
-  message: z7.string(),
-  interrupt: z7.boolean().optional(),
-  queue: z7.boolean().optional(),
-  idempotency_key: z7.string().optional()
+var SendMessageSchema = z8.object({
+  message: z8.string(),
+  interrupt: z8.boolean().optional(),
+  queue: z8.boolean().optional(),
+  /** A catalogue id: this session runs on it from this message's turn on (§7, ADR-0832). */
+  model: z8.string().min(1).optional(),
+  /** Plan mode from this message's turn on (§7.5, ADR-0905). */
+  mode: SessionModeSchema.optional(),
+  idempotency_key: z8.string().optional()
 }).refine((body) => !(body.interrupt === true && body.queue === true), {
   message: "a send is either an interrupt or queued, not both",
   path: ["queue"]
 });
-var SendAcceptedSchema = z7.object({
-  session_id: z7.string(),
+var SendAcceptedSchema = z8.object({
+  session_id: z8.string(),
   status: SessionStatusSchema,
-  accepted_seq: z7.number().int().nonnegative()
+  accepted_seq: z8.number().int().nonnegative()
 });
-var ToolConfirmationSchema = z7.object({
-  tool_call_id: z7.string(),
-  decision: z7.enum(["allow", "deny"]),
-  reason: z7.string().optional(),
-  scope: z7.enum(["call", "session"]).default("call")
+var ToolConfirmationSchema = z8.object({
+  tool_call_id: z8.string(),
+  decision: z8.enum(["allow", "deny"]),
+  reason: z8.string().optional(),
+  scope: z8.enum(["call", "session"]).default("call"),
+  /**
+   * THE PERSON'S OWN ANSWERS for a template install they approve (ADR-1030): the call runs with
+   * these in place of the `answers` the agent proposed, and with nothing else changed. A modifier on
+   * `allow`, like `scope`: absent is the call as proposed. The route refuses it on a deny, on a session
+   * grant, on any other tool, and on answers the template's questions refuse (`answerProblems`).
+   */
+  answers: InstallAnswersSchema.optional()
 });
-var SessionAnswerSchema = z7.object({
-  tool_call_id: z7.string(),
-  answers: z7.record(z7.string(), z7.union([z7.string(), z7.array(z7.string())]))
+var SessionAnswerSchema = z8.object({
+  tool_call_id: z8.string(),
+  answers: z8.record(z8.string(), z8.union([z8.string(), z8.array(z8.string())]))
 });
 
 // ../core/src/schema/event.ts
-import { z as z8 } from "zod";
-var EventTypeSchema = z8.enum([
+import { z as z9 } from "zod";
+var EventTypeSchema = z9.enum([
   "message.delta",
+  /**
+   * The agent's answer (no `role`), or a user row `{ role: "user", content, client_message_id? }` (§8).
+   * A user row the runtime wrote itself — a media job's result, a tool grant — carries
+   * `from: "platform"` and is the platform's notice, not a caller's words (§8, ADR-0870).
+   */
   "message.completed",
   /** A caller's message, durable in the inbox and not yet admitted to a turn (§7, §8): `{ client_message_id, content }`. */
   "message.accepted",
@@ -904,19 +1150,28 @@ var EventTypeSchema = z8.enum([
   "tool.started",
   "tool.completed",
   "tool.confirm",
+  /** A person's decision on a parked call, stamped with the inbox write that delivers it (§8, ADR-0764). */
+  "tool.confirm.resolved",
+  /** A person's answer to a parked question, stamped the same way (§7.1, §8, ADR-1049). */
+  "tool.confirm.answered",
   "session.running",
   "session.usage",
   "session.idle",
   /** A failed attempt the loop will retry (§8): `{ attempt, in_ms, code }`. */
   "session.retrying",
+  /** The session's mode changed (§7.5): `{ mode: "plan" | "build" }`. */
+  "session.mode",
+  /** A write to the session's plan, by the agent or its owner (§7.5): the plan object. */
+  "plan.updated",
   /**
    * The turn ran, but without something it needed (§8): `{ reason, detail? }`.
    *
    * Emitted for a turn whose sandbox could not be woken. That turn used to be indistinguishable
    * from a success — the model was handed the failure as a tool result, answered around it from the
    * transcript, and the session ended `idle`/`end_turn` with no field anywhere saying the
-   * filesystem had been unavailable. This is the field. `reason` is open on purpose; today the only
-   * value is `"sandbox_unavailable"`.
+   * filesystem had been unavailable. This is the field. `reason` is open on purpose; today it is
+   * `"sandbox_unavailable"`, `"vendor_resume_unavailable"`, or `"app_tools_unavailable"` — an app the
+   * agent's toolset names gave no tools this turn (§29.5, `runtime-do app-mcp-tools.ts`).
    *
    * `detail` is the boot failure's own message, and it is here because `reason` alone reads the
    * same for a vendor outage and for a fault of ours. Staging round 3 spent its whole budget
@@ -995,63 +1250,78 @@ var EventTypeSchema = z8.enum([
   "card.refunded",
   "card.credentials_revealed"
 ]);
-var EventSchema = z8.object({
+var EventSchema = z9.object({
   id: idOf("evt"),
-  seq: z8.number().int().positive(),
+  seq: z9.number().int().positive(),
   type: EventTypeSchema,
   session_id: idOf("ses"),
-  data: z8.record(z8.string(), z8.unknown()),
+  data: z9.record(z9.string(), z9.unknown()),
   created_at: Timestamp
 });
-var ThreadEventDataSchema = z8.looseObject({ thread_id: idOf("ses") });
-var SessionUsageDataSchema = z8.object({
+var ThreadEventDataSchema = z9.looseObject({ thread_id: idOf("ses") });
+var ToolConfirmResolvedDataSchema = z9.object({
+  tool_call_id: z9.string(),
+  decision: z9.enum(["allow", "deny"]),
+  reason: z9.string().nullable(),
+  scope: z9.enum(["call", "session"]),
+  actor: PrincipalSchema.nullable(),
+  decided_at: Timestamp,
+  proposed_args: z9.record(z9.string(), z9.unknown()).nullable(),
+  final_args: z9.record(z9.string(), z9.unknown()).nullable()
+});
+var ToolConfirmAnsweredDataSchema = z9.object({
+  tool_call_id: z9.string(),
+  answers: AnswersSchema,
+  answered_at: Timestamp
+});
+var SessionUsageDataSchema = z9.object({
   token_usage: TokenUsageSchema,
   consumed_micro_usd: MicroUsdField.nonnegative(),
-  active_seconds: z8.number().nonnegative(),
-  tool_calls: z8.number().int().nonnegative()
+  active_seconds: z9.number().nonnegative(),
+  tool_calls: z9.number().int().nonnegative()
 });
 
 // ../core/src/schema/board.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var BOARD_STATUSES = ["todo", "doing", "blocked", "done"];
-var BoardStatusSchema = z9.enum(BOARD_STATUSES);
-var BoardCountsSchema = z9.object({
-  todo: z9.number().int().nonnegative(),
-  doing: z9.number().int().nonnegative(),
-  blocked: z9.number().int().nonnegative(),
-  done: z9.number().int().nonnegative()
-});
-var BoardSchema = z9.object({
+var BoardStatusSchema = z10.enum(BOARD_STATUSES);
+var BoardCountsSchema = z10.object({
+  todo: z10.number().int().nonnegative(),
+  doing: z10.number().int().nonnegative(),
+  blocked: z10.number().int().nonnegative(),
+  done: z10.number().int().nonnegative()
+});
+var BoardSchema = z10.object({
   id: idOf("brd"),
-  object: z9.literal("board"),
+  object: z10.literal("board"),
   agent_id: idOf("agt"),
   cards: BoardCountsSchema,
   created_at: Timestamp
 });
-var BoardCardSchema = z9.object({
+var BoardCardSchema = z10.object({
   id: idOf("crd"),
-  object: z9.literal("board_card"),
+  object: z10.literal("board_card"),
   board_id: idOf("brd"),
-  title: z9.string().min(1),
+  title: z10.string().min(1),
   /** The brief — what was asked. */
-  body: z9.string(),
+  body: z10.string(),
   /** What the holder wrote back; a `done` carries one. */
-  note: z9.string().nullable().default(null),
+  note: z10.string().nullable().default(null),
   status: BoardStatusSchema,
-  assignee: z9.string().nullable(),
+  assignee: z10.string().nullable(),
   /** The cards this one waits on. A `blocked` card with an empty list is stuck on the world. */
-  blocked_by: z9.array(idOf("crd")),
+  blocked_by: z10.array(idOf("crd")),
   // The wake fields default on read: a reader whose API predates one still gets the card (§28.11).
   woken_session_id: idOf("ses").nullable().default(null),
   reported_status: BoardStatusSchema.nullable().default(null),
   /** Sessions the board has started for this card; the third is its last (§28.18). */
-  wake_count: z9.number().int().nonnegative().default(0),
+  wake_count: z10.number().int().nonnegative().default(0),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var BoardCommentSchema = z9.object({
+var BoardCommentSchema = z10.object({
   id: idOf("bcm"),
-  object: z9.literal("board_comment"),
+  object: z10.literal("board_comment"),
   card_id: idOf("crd"),
   /**
    * Who wrote it, as an id the server derived — never a name the caller supplied. A member's
@@ -1059,42 +1329,42 @@ var BoardCommentSchema = z9.object({
    * `key_` principal. The prefix is what lets a reader tell an agent's comment from a person's,
    * which is the distinction a free-text author field could not make and could be used to forge.
    */
-  author: z9.string(),
-  body: z9.string(),
+  author: z10.string(),
+  body: z10.string(),
   created_at: Timestamp
 });
 
 // ../core/src/schema/identity.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var IDENTITY_NAME_MAX = 128;
 var IDENTITY_DESCRIPTION_MAX = 1024;
-var IdentitySchema = z10.object({
+var IdentitySchema = z11.object({
   id: idOf("idn"),
-  object: z10.literal("identity"),
+  object: z11.literal("identity"),
   /** Human-facing persona name. Surfaced to the model so it acts in character. */
-  name: z10.string().min(1).max(IDENTITY_NAME_MAX),
+  name: z11.string().min(1).max(IDENTITY_NAME_MAX),
   /** What the persona is for. The model reads it to choose tone, scope and endpoint. */
-  description: z10.string().max(IDENTITY_DESCRIPTION_MAX).nullable(),
+  description: z11.string().max(IDENTITY_DESCRIPTION_MAX).nullable(),
   /** Inbox addresses (`localpart@domain`) this identity owns. */
-  emails: z10.array(z10.string()),
+  emails: z11.array(z11.string()),
   /** Provisioned numbers in E.164. */
-  phones: z10.array(z10.string()),
+  phones: z11.array(z11.string()),
   /** Verified web domains reachable through this identity's inboxes. */
-  domains: z10.array(z10.string()),
+  domains: z11.array(z11.string()),
   /** `conn_` ids of authorized third-party connections. */
-  connections: z10.array(z10.string()),
+  connections: z11.array(z11.string()),
   metadata: Metadata,
   created_at: Timestamp,
   updated_at: Timestamp
 });
 
 // ../core/src/schema/resource.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // ../core/src/schema/files-library.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var FILE_KINDS = ["image", "video", "audio", "document", "other"];
-var FileKindSchema = z11.enum(FILE_KINDS);
+var FileKindSchema = z12.enum(FILE_KINDS);
 var FILE_SOURCE_TYPES = [
   "upload",
   "url_import",
@@ -1104,176 +1374,186 @@ var FILE_SOURCE_TYPES = [
   "screenshot",
   "speech_generation"
 ];
-var FileSourceTypeSchema = z11.enum(FILE_SOURCE_TYPES);
-var FileSourceSchema = z11.object({
+var FileSourceTypeSchema = z12.enum(FILE_SOURCE_TYPES);
+var FileSourceSchema = z12.object({
   type: FileSourceTypeSchema,
-  job_id: z11.union([idOf("med"), idOf("clj")]).nullable(),
-  url: z11.string().url().nullable()
-});
-var FileTagsSchema = z11.array(z11.string().min(1).max(64)).max(32);
-var FileLibraryFieldsSchema = z11.object({
-  title: z11.string().max(256).nullable().default(null),
-  description: z11.string().max(4096).nullable().default(null),
+  job_id: z12.union([idOf("med"), idOf("clj")]).nullable(),
+  url: z12.string().url().nullable(),
+  /** What a generator was asked with (§36.1, ADR-0886); absent on every other writer's row. */
+  model: z12.string().nullable().optional(),
+  prompt: z12.string().nullable().optional()
+});
+var FileTagsSchema = z12.array(z12.string().min(1).max(64)).max(32);
+var FileLibraryFieldsSchema = z12.object({
+  title: z12.string().max(256).nullable().default(null),
+  description: z12.string().max(4096).nullable().default(null),
   tags: FileTagsSchema.default([]),
   kind: FileKindSchema.default("other"),
   source: FileSourceSchema.nullable().default(null),
   thumbnail_file_id: idOf("fil").nullable().default(null),
-  width: z11.number().int().positive().nullable().default(null),
-  height: z11.number().int().positive().nullable().default(null),
-  duration_seconds: z11.number().nonnegative().nullable().default(null)
+  width: z12.number().int().positive().nullable().default(null),
+  height: z12.number().int().positive().nullable().default(null),
+  duration_seconds: z12.number().nonnegative().nullable().default(null)
 });
-var UpdateFileSchema = z11.object({
-  title: z11.string().max(256).nullable().optional(),
-  description: z11.string().max(4096).nullable().optional(),
+var UpdateFileSchema = z12.object({
+  title: z12.string().max(256).nullable().optional(),
+  description: z12.string().max(4096).nullable().optional(),
   tags: FileTagsSchema.optional()
 });
-var ImportFileSchema = z11.object({
-  url: z11.string().url().startsWith("http"),
-  title: z11.string().max(256).optional(),
-  description: z11.string().max(4096).optional(),
+var ImportFileSchema = z12.object({
+  url: z12.string().url().startsWith("http"),
+  title: z12.string().max(256).optional(),
+  description: z12.string().max(4096).optional(),
   tags: FileTagsSchema.optional()
 });
 
 // ../core/src/schema/resource.ts
-var ComputerStatusSchema = z12.enum(["creating", "running", "paused", "failed", "destroyed"]);
-var VolumeSchema = z12.object({
+var ComputerStatusSchema = z13.enum(["creating", "running", "paused", "failed", "destroyed"]);
+var VolumeSchema = z13.object({
   id: idOf("vol"),
-  size_gb: z12.number().int().positive(),
-  mount_path: z12.string()
+  size_gb: z13.number().int().positive(),
+  mount_path: z13.string()
 });
-var ComputerSchema = z12.object({
+var ComputerSchema = z13.object({
   id: idOf("cmp"),
-  object: z12.literal("computer"),
-  name: z12.string(),
-  vcpu: z12.number().int().positive(),
-  memory_mb: z12.number().int().positive(),
-  disk_gb: z12.number().int().positive(),
+  object: z13.literal("computer"),
+  name: z13.string(),
+  vcpu: z13.number().int().positive(),
+  memory_mb: z13.number().int().positive(),
+  disk_gb: z13.number().int().positive(),
   status: ComputerStatusSchema,
   // core-gaps: U2-browser-api — the whole option object (§32.2); `{ allowed_domains }` still parses.
   browser: BrowserOptionsSchema.nullable(),
   volume: VolumeSchema.nullable(),
   snapshot_id: idOf("snp").nullable(),
+  /**
+   * The agent this computer belongs to (§41.8, ADR-0849); `null` for one made by `POST /v1/computers`.
+   * Defaulted so a reply from an older control plane parses.
+   */
+  agent_id: idOf("agt").nullable().default(null),
   created_at: Timestamp
 });
-var SnapshotSchema = z12.object({
+var SnapshotSchema = z13.object({
   snapshot_id: idOf("snp"),
   computer_id: idOf("cmp"),
   created_at: Timestamp
 });
-var ComputerProbeSchema = z12.object({
+var ComputerProbeSchema = z13.object({
   sampled_at: Timestamp,
-  uptime_seconds: z12.number().int().nonnegative(),
-  processes: z12.number().int().nonnegative(),
-  load_1m: z12.number().nonnegative(),
-  memory_used_mb: z12.number().int().nonnegative(),
-  memory_total_mb: z12.number().int().positive(),
-  disk_used_gb: z12.number().nonnegative(),
-  disk_total_gb: z12.number().positive()
-});
-var ComputerInspectSchema = z12.object({
-  object: z12.literal("computer_inspect"),
+  uptime_seconds: z13.number().int().nonnegative(),
+  processes: z13.number().int().nonnegative(),
+  load_1m: z13.number().nonnegative(),
+  memory_used_mb: z13.number().int().nonnegative(),
+  memory_total_mb: z13.number().int().positive(),
+  disk_used_gb: z13.number().nonnegative(),
+  disk_total_gb: z13.number().positive()
+});
+var ComputerInspectSchema = z13.object({
+  object: z13.literal("computer_inspect"),
   id: idOf("cmp"),
   status: ComputerStatusSchema,
   last_active_at: Timestamp.nullable(),
   /** Where the provider's file API is rooted (§41.1); `null` when it does not say. */
-  home: z12.string().min(1).nullable(),
+  home: z13.string().min(1).nullable(),
   probe: ComputerProbeSchema.nullable()
 });
 var COMMAND_OUTPUT_CAP = 65536;
-var ComputerCommandSchema = z12.object({
+var ComputerCommandSchema = z13.object({
   id: idOf("cmd"),
-  object: z12.literal("computer_command"),
+  object: z13.literal("computer_command"),
   computer_id: idOf("cmp"),
-  command: z12.string(),
-  exit_code: z12.number().int().nullable(),
-  timed_out: z12.boolean(),
-  duration_ms: z12.number().int().nonnegative(),
-  stdout: z12.string().max(COMMAND_OUTPUT_CAP),
-  stderr: z12.string().max(COMMAND_OUTPUT_CAP),
-  truncated: z12.boolean(),
+  command: z13.string(),
+  exit_code: z13.number().int().nullable(),
+  timed_out: z13.boolean(),
+  duration_ms: z13.number().int().nonnegative(),
+  stdout: z13.string().max(COMMAND_OUTPUT_CAP),
+  stderr: z13.string().max(COMMAND_OUTPUT_CAP),
+  truncated: z13.boolean(),
   actor: PrincipalSchema,
   created_at: Timestamp
 });
-var ExecStreamFrameSchema = z12.union([
-  z12.object({ stdout: z12.string() }),
-  z12.object({ stderr: z12.string() }),
-  z12.object({
-    exit: z12.object({
-      exit_code: z12.number().int().nullable(),
-      timed_out: z12.boolean(),
-      duration_ms: z12.number().int().nonnegative(),
+var ExecStreamFrameSchema = z13.union([
+  z13.object({ stdout: z13.string() }),
+  z13.object({ stderr: z13.string() }),
+  z13.object({
+    exit: z13.object({
+      exit_code: z13.number().int().nullable(),
+      timed_out: z13.boolean(),
+      duration_ms: z13.number().int().nonnegative(),
       command_id: idOf("cmd")
     })
   })
 ]);
-var FileEntryTypeSchema = z12.enum(["file", "directory", "symlink", "other"]);
-var FileEntrySchema = z12.object({
-  name: z12.string().min(1),
-  path: z12.string().min(1),
+var FileEntryTypeSchema = z13.enum(["file", "directory", "symlink", "other"]);
+var FileEntrySchema = z13.object({
+  name: z13.string().min(1),
+  path: z13.string().min(1),
   type: FileEntryTypeSchema,
-  size_bytes: z12.number().int().nonnegative(),
+  size_bytes: z13.number().int().nonnegative(),
   /** POSIX `st_mode`. */
-  mode: z12.number().int().nonnegative(),
+  mode: z13.number().int().nonnegative(),
   modified_at: Timestamp.nullable()
 });
-var ComputerUpdateSchema = z12.strictObject({ name: z12.string().min(1).max(200) });
-var SkillSchema = z12.object({
+var ComputerUpdateSchema = z13.strictObject({ name: z13.string().min(1).max(200) });
+var SkillSchema = z13.object({
   id: idOf("skl"),
-  object: z12.literal("skill"),
-  name: z12.string(),
-  description: z12.string().nullable(),
-  latest_version: z12.number().int().positive(),
+  object: z13.literal("skill"),
+  name: z13.string(),
+  description: z13.string().nullable(),
+  latest_version: z13.number().int().positive(),
   created_at: Timestamp
 });
-var ResolvedSkillRefSchema = z12.object({
+var ResolvedSkillRefSchema = z13.object({
   /** The reference exactly as the agent version wrote it: `slug` or `slug@N`. */
-  ref: z12.string().min(1),
-  slug: z12.string().min(1),
-  version: z12.number().int().positive(),
-  description: z12.string(),
-  storage_key: z12.string().min(1)
-});
-var SkillVersionSchema = z12.object({
-  version: z12.number().int().positive(),
-  sha256: z12.string().regex(/^[0-9a-f]{64}$/),
-  size_bytes: z12.number().int().nonnegative(),
+  ref: z13.string().min(1),
+  slug: z13.string().min(1),
+  version: z13.number().int().positive(),
+  description: z13.string(),
+  storage_key: z13.string().min(1)
+});
+var SkillVersionSchema = z13.object({
+  version: z13.number().int().positive(),
+  sha256: z13.string().regex(/^[0-9a-f]{64}$/),
+  size_bytes: z13.number().int().nonnegative(),
   created_at: Timestamp
 });
-var SkillCatalogEntrySchema = z12.object({
-  object: z12.literal("skill_catalog_entry"),
-  slug: z12.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  version: z12.number().int().positive(),
-  name: z12.string().min(1),
-  description: z12.string(),
-  tags: z12.array(z12.string().min(1)),
-  content_hash: z12.string().regex(/^[0-9a-f]{64}$/),
+var SkillCatalogEntrySchema = z13.object({
+  object: z13.literal("skill_catalog_entry"),
+  slug: z13.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  version: z13.number().int().positive(),
+  name: z13.string().min(1),
+  description: z13.string(),
+  tags: z13.array(z13.string().min(1)),
+  content_hash: z13.string().regex(/^[0-9a-f]{64}$/),
   published_at: Timestamp
 });
-var SkillCatalogVersionSchema = SkillCatalogEntrySchema.extend({ content: z12.string() });
-var FileSchema = z12.object({
+var SkillCatalogVersionSchema = SkillCatalogEntrySchema.extend({ content: z13.string() });
+var FileSchema = z13.object({
   id: idOf("fil"),
-  object: z12.literal("file"),
-  name: z12.string(),
-  content_type: z12.string(),
-  size_bytes: z12.number().int().nonnegative(),
-  scope: z12.enum(["session", "published"]),
+  object: z13.literal("file"),
+  name: z13.string(),
+  content_type: z13.string(),
+  size_bytes: z13.number().int().nonnegative(),
+  scope: z13.enum(["session", "published"]),
   session_id: idOf("ses").nullable(),
-  sha256: z12.string().regex(/^[0-9a-f]{64}$/),
+  sha256: z13.string().regex(/^[0-9a-f]{64}$/),
   created_at: Timestamp,
   // The asset-library fields (`canonical-spec §36.1`), all nullable or defaulted.
-  ...FileLibraryFieldsSchema.shape
+  ...FileLibraryFieldsSchema.shape,
+  /** The agent of `session_id`, joined at read (§36.1, ADR-0887); a writer never sets it. */
+  agent_id: idOf("agt").nullable().optional()
 });
-var ScheduleStatusSchema = z12.enum(["scheduled", "paused", "unscheduled"]);
-var DeploymentSchema = z12.object({
+var ScheduleStatusSchema = z13.enum(["scheduled", "paused", "unscheduled"]);
+var DeploymentSchema = z13.object({
   id: idOf("dep"),
-  object: z12.literal("deployment"),
+  object: z13.literal("deployment"),
   agent_id: idOf("agt"),
   /** A pin. `null` tracks the agent's `current_version` on every fire (§12). */
-  agent_version: z12.number().int().positive().nullable(),
-  cron: z12.string(),
+  agent_version: z13.number().int().positive().nullable(),
+  cron: z13.string(),
   /** IANA zone the `cron` is read in. "0 9 * * 1" means 09:00 *here*, across DST (ADR-0074). */
-  timezone: z12.string(),
-  input_template: z12.string(),
+  timezone: z13.string(),
+  input_template: z13.string(),
   budget_micro_usd: MicroUsdField.nonnegative(),
   window: WindowSchema,
   /**
@@ -1283,21 +1563,21 @@ var DeploymentSchema = z12.object({
    * those endpoints, and a signed delivery over cleartext is not a delivery. Until the push was
    * wired this field went nowhere, so nothing can be relying on an `http://` value (ADR-0161).
    */
-  on_idle: z12.url().startsWith("https://", { error: "a webhook URL must be https" }).nullable(),
+  on_idle: z13.url().startsWith("https://", { error: "a webhook URL must be https" }).nullable(),
   /**
    * The persona every fire speaks as, or `null` to run as nobody (§22). Written as an `idn_` id
    * **or** the persona's name, the way a session names one, and always echoed as the id: a fire at
    * 3am must not be silenced by someone renaming the persona at noon.
    */
   identity: idOf("idn").nullable(),
-  enabled: z12.boolean(),
+  enabled: z13.boolean(),
   /** Derived per deploy, never stored — the row cannot know whether a clock is watching it. */
   schedule_status: ScheduleStatusSchema,
   /** The next fire, or `null` when nothing will fire it (`schedule_status` says which). */
   next_run_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var DeploymentRunSchema = z12.object({
+var DeploymentRunSchema = z13.object({
   id: idOf("run"),
   session_id: idOf("ses"),
   status: SessionStatusSchema,
@@ -1305,62 +1585,62 @@ var DeploymentRunSchema = z12.object({
 });
 
 // ../core/src/schema/comms.ts
-import { z as z13 } from "zod";
-var DomainKindSchema = z13.enum(["system", "external", "purchased"]);
-var DomainStatusSchema = z13.enum(["pending_dns", "active", "failed"]);
-var DomainDnsStatusSchema = z13.enum(["pending_verification", "provisioned", "failed"]);
-var DomainInboundStatusSchema = z13.enum(["pending", "verified", "failed"]);
-var DomainAppConnectStatusSchema = z13.enum(["pending", "connected", "failed"]);
-var DnsRecordSchema = z13.object({
-  type: z13.enum(["TXT", "CNAME", "MX"]),
-  host: z13.string(),
-  value: z13.string(),
-  priority: z13.number().int().nullable(),
+import { z as z14 } from "zod";
+var DomainKindSchema = z14.enum(["system", "external", "purchased"]);
+var DomainStatusSchema = z14.enum(["pending_dns", "active", "failed"]);
+var DomainDnsStatusSchema = z14.enum(["pending_verification", "provisioned", "failed"]);
+var DomainInboundStatusSchema = z14.enum(["pending", "verified", "failed"]);
+var DomainAppConnectStatusSchema = z14.enum(["pending", "connected", "failed"]);
+var DnsRecordSchema = z14.object({
+  type: z14.enum(["TXT", "CNAME", "MX"]),
+  host: z14.string(),
+  value: z14.string(),
+  priority: z14.number().int().nullable(),
   /** Vetta owns this record: `_dmarc`, DKIM, inbound MX. The agent may read it, never write it. */
-  managed: z13.boolean()
+  managed: z14.boolean()
 });
-var DomainSchema = z13.object({
+var DomainSchema = z14.object({
   id: idOf("dom"),
-  object: z13.literal("domain"),
+  object: z14.literal("domain"),
   /** A domain belongs to the **organization**, not to one identity: two identities share one. */
-  name: z13.string(),
+  name: z14.string(),
   kind: DomainKindSchema,
   status: DomainStatusSchema,
   dns_status: DomainDnsStatusSchema,
   inbound_status: DomainInboundStatusSchema,
   app_connect_status: DomainAppConnectStatusSchema,
-  records: z13.array(DnsRecordSchema),
+  records: z14.array(DnsRecordSchema),
   last_verified_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var EmailInboxSchema = z13.object({
+var EmailInboxSchema = z14.object({
   id: idOf("eml"),
-  object: z13.literal("email_inbox"),
+  object: z14.literal("email_inbox"),
   identity_id: idOf("idn"),
   domain_id: idOf("dom"),
-  address: z13.string(),
-  localpart: z13.string(),
+  address: z14.string(),
+  localpart: z14.string(),
   /** Inbound routing keys off this: mail to the address wakes exactly this agent. */
   owning_agent_id: idOf("agt"),
-  status: z13.enum(["active", "disabled"]),
+  status: z14.enum(["active", "disabled"]),
   created_at: Timestamp
 });
-var PhoneTierSchema = z13.enum(["sole_prop", "standard"]);
-var BrandStatusSchema = z13.enum(["none", "pending_verification", "verified", "rejected"]);
-var CampaignStatusSchema = z13.enum(["none", "pending", "approved", "rejected"]);
-var PhoneNumberSchema = z13.object({
+var PhoneTierSchema = z14.enum(["sole_prop", "standard"]);
+var BrandStatusSchema = z14.enum(["none", "pending_verification", "verified", "rejected"]);
+var CampaignStatusSchema = z14.enum(["none", "pending", "approved", "rejected"]);
+var PhoneNumberSchema = z14.object({
   id: idOf("pho"),
-  object: z13.literal("phone_number"),
+  object: z14.literal("phone_number"),
   identity_id: idOf("idn"),
-  e164: z13.string(),
-  country: z13.string(),
-  capabilities: z13.object({
+  e164: z14.string(),
+  country: z14.string(),
+  capabilities: z14.object({
     /** Live the moment the number is bought — inbound never waits on carrier registration. */
-    sms_inbound: z13.boolean(),
+    sms_inbound: z14.boolean(),
     /** True **iff** `campaign_status === "approved"`. Nothing else may set it. */
-    sms_outbound: z13.boolean(),
+    sms_outbound: z14.boolean(),
     /** Voice is not a P2 capability; the field exists so its absence is explicit. */
-    voice: z13.literal(false)
+    voice: z14.literal(false)
   }),
   tier: PhoneTierSchema,
   brand_status: BrandStatusSchema,
@@ -1368,46 +1648,66 @@ var PhoneNumberSchema = z13.object({
   provisioned_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var InboundMessageSchema = z13.object({
+var InboundMessageSchema = z14.object({
   id: idOf("inb"),
-  object: z13.literal("inbound_message"),
-  channel: z13.enum(["email", "sms"]),
+  object: z14.literal("inbound_message"),
+  channel: z14.enum(["email", "sms"]),
   identity_id: idOf("idn"),
   /** The `eml_`/`pho_` endpoint it arrived at — the persona is decided by *where*, not by *who*. */
-  endpoint_id: z13.string(),
-  from: z13.string(),
-  to: z13.string(),
-  subject: z13.string().nullable(),
-  text: z13.string(),
+  endpoint_id: z14.string(),
+  from: z14.string(),
+  to: z14.string(),
+  subject: z14.string().nullable(),
+  text: z14.string(),
   /** SPF/DKIM/DMARC for mail, carrier origin for SMS. Kept for the audit of why it was accepted. */
-  auth: z13.record(z13.string(), z13.string()),
+  auth: z14.record(z14.string(), z14.string()),
   /** The session this message woke. Null until the wake seam lands (see ADR-0120). */
   session_id: idOf("ses").nullable(),
-  received_at: Timestamp
+  received_at: Timestamp,
+  /**
+   * When a person marked it read (`POST …/messages/{mid}/read`); `null` is unread. Defaulted so a
+   * reply from an older control plane parses (ADR-1076).
+   */
+  read_at: Timestamp.nullable().default(null)
+});
+var OutboundMessageSchema = z14.object({
+  id: idOf("out"),
+  object: z14.literal("outbound_message"),
+  channel: InboundMessageSchema.shape.channel,
+  identity_id: idOf("idn"),
+  /** The `eml_` endpoint it was sent from. */
+  endpoint_id: z14.string(),
+  from: z14.string(),
+  to: z14.array(z14.string()),
+  subject: z14.string().nullable(),
+  text: z14.string(),
+  sent_by_agent_id: idOf("agt").nullable(),
+  actor: PrincipalSchema.nullable(),
+  sent_at: Timestamp
 });
 
 // ../core/src/schema/app.ts
-import { z as z14 } from "zod";
-var AppTypeSchema = z14.enum(["frontend_only", "fullstack"]);
-var AppStatusSchema = z14.enum(["provisioning", "active", "error"]);
-var AppMcpPathSchema = z14.string().regex(/^\/\S*$/, "must be an absolute path beginning with /").max(128);
-var AppSchema = z14.object({
+import { z as z15 } from "zod";
+var AppTypeSchema = z15.enum(["frontend_only", "fullstack"]);
+var AppStatusSchema = z15.enum(["provisioning", "active", "error"]);
+var AppMcpPathSchema = z15.string().regex(/^\/\S*$/, "must be an absolute path beginning with /").max(128);
+var AppSchema = z15.object({
   id: idOf("app"),
-  object: z14.literal("app"),
-  name: z14.string(),
-  description: z14.string().nullable(),
+  object: z15.literal("app"),
+  name: z15.string(),
+  description: z15.string().nullable(),
   type: AppTypeSchema,
   /**
    * The customer's own project name that made this app, or `null` for one made outside a project
    * (ADR-0375). Customer-visible, unlike the provider handles: it is the word the customer typed,
    * and the refusal that guards a name quotes it.
    */
-  project: z14.string().nullable(),
+  project: z15.string().nullable(),
   status: AppStatusSchema,
   /** The address the app answers on — platform hostname until a custom domain connects. */
-  url: z14.string().nullable(),
+  url: z15.string().nullable(),
   /** White-label words when `status` is `error`; never the provider's. */
-  error: z14.string().nullable(),
+  error: z15.string().nullable(),
   /** Where the app serves MCP, or `null`. The bearer token for it is a server column. */
   mcp: AppMcpPathSchema.nullable(),
   /**
@@ -1415,75 +1715,80 @@ var AppSchema = z14.object({
    * than linking its `url` (`§29.1`)? True when the platform holds the app's `DASHBOARD_TOKEN`
    * or a secret of that name exists on the app; derived on read, never stored.
    */
-  dashboard: z14.boolean(),
+  dashboard: z15.boolean(),
   created_at: Timestamp
 });
-var AppDeploymentStatusSchema = z14.enum(["queued", "building", "ready", "error"]);
-var AppDeploymentSchema = z14.object({
+var AppDeploymentStatusSchema = z15.enum(["queued", "building", "ready", "error"]);
+var AppDeploymentSchema = z15.object({
   id: idOf("apd"),
-  object: z14.literal("app_deployment"),
+  object: z15.literal("app_deployment"),
   app_id: idOf("app"),
   status: AppDeploymentStatusSchema,
-  url: z14.string().nullable(),
-  error: z14.string().nullable(),
+  url: z15.string().nullable(),
+  error: z15.string().nullable(),
   /** The client's opaque digest of the files, echoed verbatim so it can skip an unchanged deploy. */
-  content_hash: z14.string().nullable(),
+  content_hash: z15.string().nullable(),
   created_at: Timestamp
 });
-var AppDeploymentFilesSchema = z14.object({
-  object: z14.literal("app_deployment_files"),
+var AppDeploymentFilesSchema = z15.object({
+  object: z15.literal("app_deployment_files"),
   deployment_id: idOf("apd"),
-  files: z14.record(z14.string().min(1), z14.string())
+  files: z15.record(z15.string().min(1), z15.string())
 });
-var AppSecretSchema = z14.object({
-  object: z14.literal("app_secret"),
-  name: z14.string(),
+var AppSecretSchema = z15.object({
+  object: z15.literal("app_secret"),
+  name: z15.string(),
   /** The client's opaque digest of the value, echoed verbatim so it can skip an unchanged write. */
-  value_hash: z14.string().nullable(),
+  value_hash: z15.string().nullable(),
   created_at: Timestamp
 });
-var AppEntrySchema = z14.object({
-  object: z14.literal("app_entry"),
-  url: z14.string(),
-  ticket: z14.string()
+var AppEntrySchema = z15.object({
+  object: z15.literal("app_entry"),
+  url: z15.string(),
+  ticket: z15.string()
 });
-var AppAccessSchema = z14.object({
-  object: z14.literal("app_access"),
-  url: z14.string().nullable(),
-  password: z14.string().nullable()
+var AppAccessSchema = z15.object({
+  object: z15.literal("app_access"),
+  url: z15.string().nullable(),
+  password: z15.string().nullable()
 });
-var AppDomainStatusSchema = z14.enum(["pending", "connected", "failed"]);
-var AppDomainSchema = z14.object({
-  object: z14.literal("app_domain"),
+var AppDomainStatusSchema = z15.enum(["pending", "connected", "failed"]);
+var AppDomainSchema = z15.object({
+  object: z15.literal("app_domain"),
   app_id: idOf("app"),
   domain_id: idOf("dom"),
-  domain: z14.string(),
+  domain: z15.string(),
   status: AppDomainStatusSchema,
   created_at: Timestamp
 });
 var ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
 var APP_NAME = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+var AppPermissionsSchema = z15.object({
+  object: z15.literal("app_permissions"),
+  app_id: idOf("app"),
+  scopes: z15.array(z15.string())
+});
 
 // ../core/src/schema/install.ts
-import { z as z15 } from "zod";
-var BlueprintInstallSourceSchema = z15.enum(["studio", "cli"]);
-var BlueprintInstallStatusSchema = z15.enum(["pending", "applied", "failed"]);
-var ResourceActionSchema = z15.enum(["created", "updated", "unchanged", "deleted", "refused"]);
-var ResourceReportSchema = z15.object({
-  name: z15.string().min(1),
+import { z as z16 } from "zod";
+var BlueprintInstallSourceSchema = z16.enum(["studio", "cli"]);
+var BlueprintInstallStatusSchema = z16.enum(["pending", "applied", "failed"]);
+var ResourceActionSchema = z16.enum(["created", "updated", "unchanged", "deleted", "refused"]);
+var ResourceReportSchema = z16.object({
+  name: z16.string().min(1),
   action: ResourceActionSchema,
   /** The `agt_`/`app_`/`ses_`… the line resolved to. Absent on a refusal that never got an id. */
-  id: z15.string().optional(),
+  id: z16.string().optional(),
   /** An app's hostname once its build went live; `null` while it has none. Apps only. */
-  url: z15.string().nullable().optional(),
+  url: z16.string().nullable().optional(),
   /**
    * What a TASK is called and who owes it. `name` is the declaration key (`first-render`), which is
    * how a re-apply finds the same card and is not a sentence anybody wants read to them. The
    * dashboard's opening message lists the team's work, so it needs the title the board shows and the
    * seat that holds it. Tasks only.
    */
-  title: z15.string().optional(),
-  assignee: z15.string().optional(),
+  title: z16.string().optional(),
+  assignee: z16.string().optional(),
   /**
    * A SCHEDULE'S brief, in one short line — the opening sentence of its `input_template`. A
    * schedules line is named `<agent> @ <cron>`, which says when something runs and nothing at all
@@ -1491,50 +1796,50 @@ var ResourceReportSchema = z15.object({
    * Written here rather than read back from the deployment so the receipt stays the one read the
    * welcome needs. Schedules only.
    */
-  summary: z15.string().optional(),
-  reason: z15.string().optional()
-});
-var BlueprintReportSchema = z15.object({
-  skills: z15.array(ResourceReportSchema),
-  identities: z15.array(ResourceReportSchema),
-  vaults: z15.array(ResourceReportSchema),
-  apps: z15.array(ResourceReportSchema),
-  agents: z15.array(ResourceReportSchema),
-  schedules: z15.array(ResourceReportSchema),
-  intake: z15.array(ResourceReportSchema),
+  summary: z16.string().optional(),
+  reason: z16.string().optional()
+});
+var BlueprintReportSchema = z16.object({
+  skills: z16.array(ResourceReportSchema),
+  identities: z16.array(ResourceReportSchema),
+  vaults: z16.array(ResourceReportSchema),
+  apps: z16.array(ResourceReportSchema),
+  agents: z16.array(ResourceReportSchema),
+  schedules: z16.array(ResourceReportSchema),
+  intake: z16.array(ResourceReportSchema),
   /** One line per declared task (§31.11), `id` the card's `crd_`. Defaulted so older rows parse. */
-  tasks: z15.array(ResourceReportSchema).default([]),
-  skipped: z15.array(z15.string()),
-  deselected: z15.array(z15.string()).default([])
+  tasks: z16.array(ResourceReportSchema).default([]),
+  skipped: z16.array(z16.string()),
+  deselected: z16.array(z16.string()).default([])
 });
-var BlueprintSelectionSchema = z15.object({
-  agents: z15.array(z15.string().min(1)),
-  apps: z15.array(z15.string().min(1))
+var BlueprintSelectionSchema = z16.object({
+  agents: z16.array(z16.string().min(1)),
+  apps: z16.array(z16.string().min(1))
 });
-var BlueprintInstallSchema = z15.object({
+var BlueprintInstallSchema = z16.object({
   id: idOf("bpi"),
-  object: z15.literal("blueprint_install"),
+  object: z16.literal("blueprint_install"),
   /** The customer's own `defineProject({ name })` — the same word `app.project` stamps (§29.2). */
-  project: z15.string().min(1),
+  project: z16.string().min(1),
   /** The pair the declaration resolved to; `null` for a declaration that names no blueprint. */
-  blueprint: z15.string().nullable(),
-  template: z15.string().nullable(),
+  blueprint: z16.string().nullable(),
+  template: z16.string().nullable(),
   /**
    * Applies, not versions of anything: 1 on the first apply, +1 on each one after, whichever writer
    * made it. It is not an agent version and it never rolls back.
    */
-  revision: z15.number().int().positive(),
+  revision: z16.number().int().positive(),
   /**
    * The blueprint artifact version this came from, or `null` when it was applied from a working
    * tree — an operator editing a clone has no version to name.
    */
-  artifact_version: z15.string().nullable(),
+  artifact_version: z16.string().nullable(),
   /**
    * The setup answers this project was configured with (§7.1 fields, keyed by their `key`), so a
    * re-apply does not re-ask and both writers configure from the same answers. Configuration only:
    * a secret is a vault credential (§23) or an app secret (§29.2), and neither is ever an answer.
    */
-  answers: z15.record(z15.string(), z15.unknown()),
+  answers: z16.record(z16.string(), z16.unknown()),
   /**
    * NO `declaration` ON THE WIRE, and that is the reconciliation of §29.6 with §31.1.
    *
@@ -1562,8 +1867,11 @@ var BlueprintInstallSchema = z15.object({
    */
   report: BlueprintReportSchema.nullable(),
   status: BlueprintInstallStatusSchema,
-  /** Why a `failed` run threw, in one sentence; `null` on every other row. Never a stack or a key. */
-  failure: z15.string().nullable(),
+  /**
+   * Why a `failed` run threw, in one sentence — or, on an `applied` row, which `required` agent or
+   * app the apply refused and why (§29.6). `null` otherwise. Never a stack or a key.
+   */
+  failure: z16.string().nullable(),
   /**
    * The `selection` the apply carried, or `null` — every row written before §31.2 and every apply
    * that omitted it, both meaning "everything". Defaulted so those rows parse unchanged.
@@ -1571,119 +1879,37 @@ var BlueprintInstallSchema = z15.object({
   selection: BlueprintSelectionSchema.nullable().default(null),
   /** When the answers were last edited through `PATCH …/installs/{id}` (§31.8); `null` if never. */
   context_updated_at: Timestamp.nullable().default(null),
+  /**
+   * What this install's agent, app, identity and vault names start with (§29.6, ADR-1104): `""`
+   * when its template's names were free in the organization, `"<project>-"` when any was already
+   * another project's. Decided once, by the apply that created the row, and never again. `null` is
+   * an install from before that rule, or one a working tree recorded: its names are the template's.
+   * Optional only so a Worker from before the field still parses; this API always sends it.
+   */
+  name_prefix: z16.string().nullable().optional(),
   applied_at: Timestamp,
   created_at: Timestamp
 });
-var ProjectContextAnswerSchema = z15.object({
-  key: z15.string().min(1),
-  label: z15.string(),
-  value: z15.union([z15.string(), z15.array(z15.string())])
-});
-var ProjectContextSchema = z15.object({
-  object: z15.literal("project_context"),
-  project: z15.string().min(1),
-  blueprint: z15.string().nullable(),
-  template: z15.string().nullable(),
-  artifact_version: z15.string().nullable(),
-  answers: z15.array(ProjectContextAnswerSchema),
-  apps: z15.array(z15.object({ name: z15.string().min(1), url: z15.string().nullable() })),
-  agents: z15.array(z15.object({ name: z15.string().min(1), role: z15.string().nullable() })),
+var ProjectContextAnswerSchema = z16.object({
+  key: z16.string().min(1),
+  label: z16.string(),
+  value: z16.union([z16.string(), z16.array(z16.string())])
+});
+var ProjectContextSchema = z16.object({
+  object: z16.literal("project_context"),
+  project: z16.string().min(1),
+  blueprint: z16.string().nullable(),
+  template: z16.string().nullable(),
+  artifact_version: z16.string().nullable(),
+  answers: z16.array(ProjectContextAnswerSchema),
+  apps: z16.array(z16.object({ name: z16.string().min(1), url: z16.string().nullable() })),
+  agents: z16.array(z16.object({ name: z16.string().min(1), role: z16.string().nullable() })),
   /** `context_updated_at` once the answers have been edited, `applied_at` until then. */
   updated_at: Timestamp
 });
 
 // ../core/src/schema/blueprint.ts
 import { z as z17 } from "zod";
-
-// ../core/src/schema/social.ts
-import { z as z16 } from "zod";
-var SOCIAL_PLATFORMS = [
-  "bluesky",
-  "facebook",
-  "instagram",
-  "linkedin",
-  "mastodon",
-  "pinterest",
-  "reddit",
-  "threads",
-  "tiktok",
-  "x",
-  "youtube"
-];
-var SOCIAL_APPS = /* @__PURE__ */ new Set([...SOCIAL_PLATFORMS, "twitter"]);
-var SOCIAL_TEXT_PLATFORMS = [
-  "bluesky",
-  "facebook",
-  "linkedin",
-  "mastodon",
-  "threads",
-  "x"
-];
-var SOCIAL_MEDIA_PLATFORMS = ["instagram", "tiktok", "youtube"];
-var SOCIAL_VISIBILITIES = ["public", "unlisted", "private"];
-var SOCIAL_VISIBILITY_PLATFORMS = ["mastodon", "youtube"];
-var SocialVisibilitySchema = z16.enum(SOCIAL_VISIBILITIES);
-var SOCIAL_VISIBILITY_RULE = `visibility is ${SOCIAL_VISIBILITIES.join(", ")} and only ${SOCIAL_VISIBILITY_PLATFORMS.join(" and ")} accept it; omit it and the post publishes at the account's own default, which on a video channel is normally public`;
-var SocialPlatformSchema = z16.enum(SOCIAL_PLATFORMS);
-var SocialTextPlatformSchema = z16.enum(SOCIAL_TEXT_PLATFORMS);
-var isText = (platform) => SOCIAL_TEXT_PLATFORMS.includes(platform);
-var isMedia = (platform) => SOCIAL_MEDIA_PLATFORMS.includes(platform);
-var SOCIAL_PLATFORM_RULE = `${SOCIAL_TEXT_PLATFORMS.join(", ")} take a text-only post; ${SOCIAL_MEDIA_PLATFORMS.join(", ")} may be named only when the post carries media_urls or file_ids; ${SOCIAL_PLATFORMS.filter((platform) => !isText(platform) && !isMedia(platform)).join(", ")} cannot be posted to`;
-var SocialAccountSchema = z16.object({
-  id: z16.string().min(1),
-  object: z16.literal("social_account"),
-  identity_id: idOf("idn"),
-  platform: SocialPlatformSchema,
-  username: z16.string().nullable(),
-  display_name: z16.string().nullable(),
-  avatar_url: z16.url().nullable(),
-  connected_at: Timestamp.nullable()
-});
-var SocialPostStatusSchema = z16.enum([
-  "draft",
-  "scheduled",
-  "processing",
-  "posted",
-  "failed",
-  "deleted"
-]);
-var SocialPostSchema = z16.object({
-  id: z16.string().min(1),
-  object: z16.literal("social_post"),
-  identity_id: idOf("idn"),
-  title: z16.string(),
-  platforms: z16.array(SocialPlatformSchema),
-  status: SocialPostStatusSchema,
-  scheduled_at: Timestamp.nullable(),
-  posted_at: Timestamp.nullable(),
-  error: z16.string().nullable()
-});
-var SocialUploadSchema = z16.object({
-  id: z16.string().min(1),
-  object: z16.literal("social_upload"),
-  identity_id: idOf("idn"),
-  type: z16.enum(["image", "video", "document"]),
-  url: z16.url().nullable()
-});
-var SocialAnalyticsSchema = z16.object({
-  object: z16.literal("social_analytics"),
-  identity_id: idOf("idn"),
-  resource_id: z16.string().min(1),
-  platform: SocialPlatformSchema.nullable(),
-  data: z16.unknown()
-});
-var SocialCommentSchema = z16.object({
-  id: z16.string().min(1),
-  object: z16.literal("social_comment"),
-  identity_id: idOf("idn"),
-  post_id: z16.string().min(1),
-  platforms: z16.array(SocialPlatformSchema),
-  status: SocialPostStatusSchema,
-  posted_at: Timestamp.nullable(),
-  data: z16.unknown()
-});
-
-// ../core/src/schema/blueprint.ts
 var BlueprintScheduleSchema = z17.object({
   agent: z17.string().min(1),
   cron: z17.string().min(1),
@@ -1715,16 +1941,9 @@ var BlueprintAppSchema = z17.object({
   /** Whether an install may deselect it (§31.2). Optional: the rollout argument above. */
   required: z17.boolean().optional()
 });
-var BlueprintIdentityConnectionsSchema = z17.object({
-  social: z17.object({
-    from: z17.string().min(1),
-    map: z17.record(z17.string().min(1), SocialPlatformSchema)
-  }).optional()
-});
 var BlueprintIdentitySchema = z17.object({
   name: z17.string().min(1),
-  description: z17.string().nullable(),
-  connections: BlueprintIdentityConnectionsSchema.optional()
+  description: z17.string().nullable()
 });
 var ContentHashSchema = z17.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
 var BlueprintTreeSchema = z17.object({
@@ -1742,11 +1961,18 @@ var BlueprintArtifactSchema = z17.object({
   /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
   version: z17.string().min(1),
   /**
-   * The built trees, one per deployable app, ordered as the declaration orders its apps. Never
-   * empty: an artifact that built nothing is not an artifact, and the column behind it says so
-   * (migration 0040) exactly as the single `content_hash` it replaces was `not null`.
+   * 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).min(1),
+  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
@@ -1800,6 +2026,13 @@ var VaultCredentialSchema = z18.object({
   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(),
@@ -1847,7 +2080,12 @@ var SessionHandoffSchema = z19.object({
 var ChannelBriefSchema = z19.object({
   root_session_id: idOf("ses"),
   name: z19.string().min(1),
-  members: z19.array(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)
@@ -1858,37 +2096,241 @@ var ChannelPostSchema = z19.object({
   queued: z19.boolean()
 });
 
-// ../core/src/schema/media.ts
+// ../core/src/schema/show.ts
 import { z as z20 } from "zod";
-var MEDIA_JOB_KINDS = ["video", "clip", "transcription"];
-var MediaJobKindSchema = z20.enum(MEDIA_JOB_KINDS);
-var MediaJobStatusSchema = z20.enum(["queued", "processing", "completed", "failed"]);
-var PublicUrl = z20.string().url().startsWith("http");
-var Score = z20.number().int().min(0).max(100);
-var Seconds = z20.number().nonnegative();
-var VideoResultSchema = z20.object({
-  files: z20.array(
+var SHOW_SOURCES = ["spend_by_day", "post_views", "roadmap", "schedule"];
+var ShowSourceSchema = z20.enum(SHOW_SOURCES);
+var ShowArgsSchema = z20.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.")
+});
+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"),
+  ...head,
+  days: z20.array(z20.object({ day: Day, micro_usd: Count })).min(2).max(30)
+});
+var PostViewsViewSchema = z20.object({
+  source: z20.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)
+});
+var RoadmapViewSchema = z20.object({
+  source: z20.literal("roadmap"),
+  ...head,
+  groups: z20.array(
     z20.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)
+    })
+  )
+});
+var ScheduleViewSchema = z20.object({
+  source: z20.literal("schedule"),
+  ...head,
+  days: z20.array(
+    z20.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() })
+        ])
+      ).max(8)
+    })
+  ).max(7)
+});
+var ShowViewSchema = z20.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();
+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.");
+function bound(sources2, shape) {
+  const example = JSON.stringify({ $source: sources2[0] });
+  return z21.strictObject(
+    { $source: z21.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 }
+  );
+}
+var Bound = {
+  value: bound(["views_total", "spend_total"], { days: Days }).describe(
+    "views_total: the latest views of the posts published in the window. spend_total: the company's spend in the window (the CEO only)."
+  ),
+  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(
+    "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."),
+  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.')
+};
+var SpendDay = z21.strictObject({ day: z21.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 })
+  ]),
+  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)
+};
+var box = { children: z21.array(Key).min(1).max(12) };
+var leaf = { children: z21.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);
+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."),
+    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."),
+    Progress: element("Progress", { label: words(40), progress: slot.progress }, leaf, "A value against its goal, as a bar."),
+    Roadmap: element("Roadmap", { label, board: slot.board }, leaf, "The board grouped by status."),
+    Schedule: element("Schedule", { label, week: slot.week }, leaf, "The week ahead, day by day."),
+    Media: element("Media", { label, files: slot.media }, leaf, "Pictures or clips the company holds."),
+    Text: element("Text", { text: words(240) }, leaf, "A short note in words.")
+  };
+}
+var unknownComponent = (names) => ({
+  error: (issue) => issue.code === "invalid_union" ? `unknown component: use one of ${names.join(", ")}` : void 0
+});
+function tree(rootType, max, spec2, ctx) {
+  const refuse2 = (message3, path = []) => ctx.addIssue({ code: "custom", message: message3, path });
+  const keys = Object.keys(spec2.elements);
+  const has = (key) => Object.hasOwn(spec2.elements, key);
+  if (keys.length > max) return refuse2(`at most ${max} elements`, ["elements"]);
+  const root = has(spec2.root) ? spec2.elements[spec2.root] : void 0;
+  if (!root) return refuse2(`root names "${spec2.root}", which is not in elements`, ["root"]);
+  if (root.type !== rootType) return refuse2(`the root must be a ${rootType}`, ["root"]);
+  const parent = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    for (const child of spec2.elements[key].children ?? []) {
+      if (!has(child)) return refuse2(`"${child}" is not in elements`, ["elements", key, "children"]);
+      if (child === spec2.root || parent.has(child)) return refuse2(`"${child}" has more than one parent`, ["elements", key, "children"]);
+      if (spec2.elements[child].type === rootType) return refuse2(`a ${rootType} is the root only; group with Stack or Grid`, ["elements", child, "type"]);
+      parent.set(child, key);
+    }
+  }
+  const reached = /* @__PURE__ */ new Set([spec2.root]);
+  for (const key of reached) for (const child of spec2.elements[key].children ?? []) reached.add(child);
+  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));
+
+// ../core/src/schema/compose.ts
+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(
+    "type",
+    [
+      BoundComponents.Card,
+      BoundComponents.Stack,
+      BoundComponents.Grid,
+      BoundComponents.Metric,
+      BoundComponents.LineChart,
+      BoundComponents.BarList,
+      BoundComponents.Progress,
+      BoundComponents.Roadmap,
+      BoundComponents.Schedule,
+      BoundComponents.Media,
+      BoundComponents.Text
+    ],
+    unknownComponent(COMPOSE_COMPONENTS)
+  ),
+  "Card",
+  MAX_COMPOSE_ELEMENTS
+);
+var ComposeArgsSchema = z22.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(
+    "type",
+    [
+      ComposedComponents.Card,
+      ComposedComponents.Stack,
+      ComposedComponents.Grid,
+      ComposedComponents.Metric,
+      ComposedComponents.LineChart,
+      ComposedComponents.BarList,
+      ComposedComponents.Progress,
+      ComposedComponents.Roadmap,
+      ComposedComponents.Schedule,
+      ComposedComponents.Media,
+      ComposedComponents.Text
+    ],
+    unknownComponent(COMPOSE_COMPONENTS)
+  ),
+  "Card",
+  MAX_COMPOSE_ELEMENTS
+);
+var ComposedSchema = z22.object({ as_of: Timestamp, timezone: z22.string().min(1), spec: ComposedSpecSchema });
+
+// ../core/src/schema/media.ts
+import { z as z23 } 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({
       file_id: idOf("fil"),
-      content_type: z20.string(),
-      width: z20.number().int().positive().nullable(),
-      height: z20.number().int().positive().nullable(),
+      content_type: z23.string(),
+      width: z23.number().int().positive().nullable(),
+      height: z23.number().int().positive().nullable(),
       duration_seconds: Seconds.nullable()
     })
   )
 });
-var ViralityScoreSchema = z20.object({
+var ViralityScoreSchema = z23.object({
   total: Score,
   shareability: Score,
   hook_strength: Score,
   story_quality: Score,
   emotional_impact: Score
 });
-var ClipResultSchema = z20.object({
-  clips: z20.array(
-    z20.object({
+var ClipResultSchema = z23.object({
+  clips: z23.array(
+    z23.object({
       file_id: idOf("fil"),
-      title: z20.string(),
+      title: z23.string(),
       start_seconds: Seconds,
       end_seconds: Seconds,
       duration_seconds: Seconds,
@@ -1896,189 +2338,192 @@ var ClipResultSchema = z20.object({
     })
   )
 });
-var TranscriptSchema = z20.object({
-  text: z20.string(),
-  language: z20.string().nullable(),
+var TranscriptSchema = z23.object({
+  text: z23.string(),
+  language: z23.string().nullable(),
   duration_seconds: Seconds.nullable(),
-  segments: z20.array(z20.object({ start_seconds: Seconds, end_seconds: Seconds, text: z20.string() }))
+  segments: z23.array(z23.object({ start_seconds: Seconds, end_seconds: Seconds, text: z23.string() }))
 });
-var MediaJobResultSchema = z20.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
-var MediaJobSchema = z20.object({
+var MediaJobResultSchema = z23.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
+var MediaJobSchema = z23.object({
   id: idOf("med"),
-  object: z20.literal("media_job"),
+  object: z23.literal("media_job"),
   kind: MediaJobKindSchema,
   status: MediaJobStatusSchema,
-  model: z20.string().nullable(),
-  input: z20.record(z20.string(), z20.unknown()),
+  model: z23.string().nullable(),
+  input: z23.record(z23.string(), z23.unknown()),
   result: MediaJobResultSchema.nullable(),
-  error: z20.object({ code: z20.string(), message: z20.string() }).nullable(),
+  error: z23.object({ code: z23.string(), message: z23.string() }).nullable(),
   cost_micro_usd: MicroUsdField.nullable(),
   session_id: idOf("ses").nullable(),
   created_at: Timestamp,
   completed_at: Timestamp.nullable()
 });
-var ImageRequestSchema = z20.object({
-  model: z20.string().min(1).optional(),
-  prompt: z20.string().min(1),
-  image_urls: z20.array(PublicUrl).max(4).optional(),
-  aspect_ratio: z20.string().optional(),
-  seed: z20.number().int().optional(),
-  n: z20.number().int().min(1).max(4).default(1)
-});
-var VideoRequestSchema = z20.object({
-  model: z20.string().min(1),
-  prompt: z20.string().min(1),
-  image_urls: z20.array(PublicUrl).max(1).optional(),
-  aspect_ratio: z20.string().optional(),
-  seed: z20.number().int().optional(),
-  seconds: z20.number().int().min(1).max(60).optional()
-});
-var ImageGenerationSchema = z20.object({
-  object: z20.literal("image_generation"),
-  model: z20.string(),
-  files: z20.array(FileSchema),
+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 VideoRequestSchema = z23.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(),
+  /** 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),
   cost_micro_usd: MicroUsdField
 });
-var ClipLength = z20.number().int().min(5).max(180);
-var ClipRequestSchema = z20.object({
+var ClipLength = z23.number().int().min(5).max(180);
+var ClipRequestSchema = z23.object({
   video_url: PublicUrl,
-  aspect_ratio: z20.enum(["9:16", "16:9"]).default("9:16"),
-  remove_silence: z20.boolean().default(false),
-  caption_preset: z20.enum(["none", "clean", "bold", "karaoke"]).default("none"),
-  language: z20.string().min(2).optional(),
+  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(),
   min_seconds: ClipLength.default(15),
   max_seconds: ClipLength.default(60),
-  title: z20.string().min(1).optional()
+  title: z23.string().min(1).optional()
 });
-var AudioFormatSchema = z20.enum(["mp3", "wav", "ogg"]);
-var TranscriptionRequestSchema = z20.object({
-  model: z20.string().min(1).optional(),
+var AudioFormatSchema = z23.enum(["mp3", "wav", "ogg"]);
+var TranscriptionRequestSchema = z23.object({
+  model: z23.string().min(1).optional(),
   file_id: idOf("fil").optional(),
   url: PublicUrl.optional(),
-  language: z20.string().min(2).optional(),
-  timestamps: z20.boolean().default(true)
+  language: z23.string().min(2).optional(),
+  timestamps: z23.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 = z20.object({
-  model: z20.string().min(1).optional(),
-  text: z20.string().min(1).max(4096),
-  voice: z20.string().min(1).optional(),
+var SpeechRequestSchema = z23.object({
+  model: z23.string().min(1).optional(),
+  text: z23.string().min(1).max(4096),
+  voice: z23.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3"),
-  speed: z20.number().min(0.5).max(2).optional()
+  speed: z23.number().min(0.5).max(2).optional()
 });
-var SpeechToSpeechRequestSchema = z20.object({
-  model: z20.string().min(1).optional(),
+var SpeechToSpeechRequestSchema = z23.object({
+  model: z23.string().min(1).optional(),
   file_id: idOf("fil"),
-  voice: z20.string().min(1).optional(),
+  voice: z23.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3")
 });
-var SpeechGenerationSchema = z20.object({
-  object: z20.literal("speech_generation"),
-  model: z20.string(),
+var SpeechGenerationSchema = z23.object({
+  object: z23.literal("speech_generation"),
+  model: z23.string(),
   file: FileSchema,
   duration_seconds: Seconds.nullable(),
   cost_micro_usd: MicroUsdField
 });
 
 // ../core/src/schema/app-data.ts
-import { z as z21 } from "zod";
-var DbTableSchema = z21.object({
-  object: z21.literal("db_table"),
-  name: z21.string(),
-  schema: z21.string().default("public"),
-  rows: z21.number().int().nonnegative().nullable(),
-  size_bytes: z21.number().int().nonnegative().nullable()
-});
-var DbMigrationSchema = z21.object({
+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({
   id: idOf("dbm"),
-  object: z21.literal("db_migration"),
-  name: z21.string(),
-  sha256: z21.string().regex(/^[0-9a-f]{64}$/),
+  object: z24.literal("db_migration"),
+  name: z24.string(),
+  sha256: z24.string().regex(/^[0-9a-f]{64}$/),
   applied_at: Timestamp,
-  statements: z21.number().int().nonnegative()
+  statements: z24.number().int().nonnegative()
 });
-var ApplyDbMigrationSchema = z21.object({
-  name: z21.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
-  sql: z21.string().min(1)
+var ApplyDbMigrationSchema = z24.object({
+  name: z24.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
+  sql: z24.string().min(1)
 });
 var DB_REST_METHODS = ["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD"];
-var DbRestMethodSchema = z21.enum(DB_REST_METHODS);
+var DbRestMethodSchema = z24.enum(DB_REST_METHODS);
 var BUCKET_NAME = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
-var BucketSchema = z21.object({
-  object: z21.literal("bucket"),
-  name: z21.string().regex(BUCKET_NAME),
-  public: z21.boolean(),
+var BucketSchema = z24.object({
+  object: z24.literal("bucket"),
+  name: z24.string().regex(BUCKET_NAME),
+  public: z24.boolean(),
   created_at: Timestamp
 });
-var CreateBucketSchema = z21.object({
-  name: z21.string().regex(BUCKET_NAME, { error: "3\u201363 lowercase letters, digits and hyphens" }),
-  public: z21.boolean().default(false)
-});
-var StorageObjectSchema = z21.object({
-  object: z21.literal("storage_object"),
-  bucket: z21.string(),
-  key: z21.string().min(1),
-  size_bytes: z21.number().int().nonnegative(),
-  content_type: z21.string(),
-  etag: z21.string().nullable(),
+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(),
   updated_at: Timestamp
 });
-var SignedUrlMethodSchema = z21.enum(["PUT", "GET"]);
-var SignedUrlSchema = z21.object({
-  object: z21.literal("signed_url"),
-  url: z21.string().url(),
+var SignedUrlMethodSchema = z24.enum(["PUT", "GET"]);
+var SignedUrlSchema = z24.object({
+  object: z24.literal("signed_url"),
+  url: z24.string().url(),
   method: SignedUrlMethodSchema,
   expires_at: Timestamp
 });
-var CreateUploadUrlSchema = z21.object({
-  content_type: z21.string().min(1),
-  expires_seconds: z21.number().int().min(60).max(3600).default(900)
+var CreateUploadUrlSchema = z24.object({
+  content_type: z24.string().min(1),
+  expires_seconds: z24.number().int().min(60).max(3600).default(900)
 });
 
 // ../core/src/schema/stock-photo.ts
-import { z as z22 } from "zod";
+import { z as z25 } from "zod";
 var STOCK_PHOTO_ORIENTATIONS = ["landscape", "portrait", "square"];
 var STOCK_PHOTO_SIZES = ["small", "medium", "large"];
-var StockPhotoQuerySchema = z22.object({
-  query: z22.string().min(1).max(200),
-  count: z22.coerce.number().int().min(1).max(30).default(10),
-  orientation: z22.enum(STOCK_PHOTO_ORIENTATIONS).optional(),
-  color: z22.string().min(1).max(32).optional(),
-  size: z22.enum(STOCK_PHOTO_SIZES).optional()
-});
-var StockPhotoSchema = z22.object({
-  object: z22.literal("stock_photo"),
-  id: z22.string().min(1),
-  width: z22.number().int().positive(),
-  height: z22.number().int().positive(),
-  url: z22.string().url(),
-  preview_url: z22.string().url(),
-  alt: z22.string().nullable(),
-  photographer: z22.string().nullable(),
-  attribution_url: z22.string().url().nullable(),
-  dominant_color: z22.string().nullable()
+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()
 });
 
 // ../core/src/schema/creator.ts
-import { z as z23 } from "zod";
-var CreatorCodeSchema = z23.string().regex(/^[a-z0-9]{3,24}$/, "3 to 24 lowercase letters or digits");
-var PayoutMethodSchema = z23.enum(["wise", "paypal"]);
-var PayoutDetailsSchema = z23.object({
+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({
   method: PayoutMethodSchema,
-  account: z23.string().min(1).max(320)
+  account: z26.string().min(1).max(320)
 });
-var CreatorStatusSchema = z23.enum(["active", "suspended"]);
-var CreatorSchema = z23.object({
+var CreatorStatusSchema = z26.enum(["active", "suspended"]);
+var CreatorSchema = z26.object({
   id: idOf("crt"),
-  object: z23.literal("creator"),
-  email: z23.email(),
-  display_name: z23.string().min(1).max(80),
+  object: z26.literal("creator"),
+  email: z26.email(),
+  display_name: z26.string().min(1).max(80),
   code: CreatorCodeSchema,
   status: CreatorStatusSchema,
   payout: PayoutDetailsSchema.nullable(),
-  clicks: z23.number().int().nonnegative(),
+  clicks: z26.number().int().nonnegative(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -2086,28 +2531,28 @@ var IdentityCreatorSchema = CreatorSchema.pick({
   id: true,
   status: true
 });
-var CreatorApplicationStatusSchema = z23.enum([
+var CreatorApplicationStatusSchema = z26.enum([
   "pending",
   "approved",
   "rejected"
 ]);
-var CreatorApplicationSchema = z23.object({
+var CreatorApplicationSchema = z26.object({
   id: idOf("cra"),
-  object: z23.literal("creator_application"),
-  email: z23.email(),
-  display_name: z23.string().min(1).max(80),
-  pitch: z23.string().min(1).max(2e3),
-  links: z23.array(z23.url({ protocol: /^https$/ })).max(5),
+  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),
   status: CreatorApplicationStatusSchema,
-  note: z23.string().nullable(),
+  note: z26.string().nullable(),
   creator_id: idOf("crt").nullable(),
   created_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var ReferralStatusSchema = z23.enum(["pending", "active", "expired"]);
-var ReferralSchema = z23.object({
+var ReferralStatusSchema = z26.enum(["pending", "active", "expired"]);
+var ReferralSchema = z26.object({
   id: idOf("crf"),
-  object: z23.literal("referral"),
+  object: z26.literal("referral"),
   creator_id: idOf("crt"),
   organization_id: idOf("org"),
   status: ReferralStatusSchema,
@@ -2115,16 +2560,16 @@ var ReferralSchema = z23.object({
   first_paid_at: Timestamp.nullable(),
   commission_until: Timestamp.nullable()
 });
-var CommissionKindSchema = z23.enum(["referral", "template"]);
-var CommissionStatusSchema = z23.enum([
+var CommissionKindSchema = z26.enum(["referral", "template"]);
+var CommissionStatusSchema = z26.enum([
   "pending",
   "available",
   "claimed",
   "paid"
 ]);
-var CommissionSchema = z23.object({
+var CommissionSchema = z26.object({
   id: idOf("crc"),
-  object: z23.literal("commission"),
+  object: z26.literal("commission"),
   creator_id: idOf("crt"),
   kind: CommissionKindSchema,
   referral_id: idOf("crf").nullable(),
@@ -2137,18 +2582,18 @@ var CommissionSchema = z23.object({
   available_at: Timestamp,
   payout_id: idOf("crp").nullable()
 });
-var PayoutStatusSchema = z23.enum(["requested", "paid", "rejected"]);
-var PayoutSchema = z23.object({
+var PayoutStatusSchema = z26.enum(["requested", "paid", "rejected"]);
+var PayoutSchema = z26.object({
   id: idOf("crp"),
-  object: z23.literal("payout"),
+  object: z26.literal("payout"),
   creator_id: idOf("crt"),
   amount_micro_usd: MicroUsdField.positive(),
-  currency: z23.literal("USD"),
+  currency: z26.literal("USD"),
   method: PayoutMethodSchema,
-  account: z23.string().min(1),
+  account: z26.string().min(1),
   status: PayoutStatusSchema,
-  reference: z23.string().nullable(),
-  note: z23.string().nullable(),
+  reference: z26.string().nullable(),
+  note: z26.string().nullable(),
   requested_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
@@ -2160,100 +2605,100 @@ var CREATOR_PROGRAM = {
   attribution_days: 30,
   minimum_payout_micro_usd: 2e7
 };
-var CreatorTemplateSlugSchema = z23.string().max(32).regex(
+var CreatorTemplateSlugSchema = z26.string().max(32).regex(
   /^[a-z0-9]+(-[a-z0-9]+)*$/,
   "lowercase letters, digits and single dashes"
 );
-var CreatorSkillSchema = z23.object({
-  slug: z23.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  body: z23.string().min(1).max(64 * 1024)
+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 = z23.object({
-  agents: z23.array(z23.unknown()),
-  questions: z23.array(z23.unknown()),
-  skills: z23.array(CreatorSkillSchema).max(16)
+var CreatorDeclarationSchema = z26.object({
+  agents: z26.array(z26.unknown()),
+  questions: z26.array(z26.unknown()),
+  skills: z26.array(CreatorSkillSchema).max(16)
 });
-var CreatorTemplateVersionStatusSchema = z23.enum([
+var CreatorTemplateVersionStatusSchema = z26.enum([
   "in_review",
   "approved",
   "changes_requested"
 ]);
-var VersionNumber = z23.number().int().positive();
-var CreatorTemplateSchema = z23.object({
+var VersionNumber = z26.number().int().positive();
+var CreatorTemplateSchema = z26.object({
   id: idOf("ctp"),
-  object: z23.literal("creator_template"),
+  object: z26.literal("creator_template"),
   creator_id: idOf("crt"),
-  blueprint: z23.string().min(1),
-  base_template: z23.string().min(1),
+  blueprint: z26.string().min(1),
+  base_template: z26.string().min(1),
   slug: CreatorTemplateSlugSchema,
-  template: z23.string().min(1).max(64),
-  name: z23.string().min(1).max(80),
-  description: z23.string().max(2e3),
+  template: z26.string().min(1).max(64),
+  name: z26.string().min(1).max(80),
+  description: z26.string().max(2e3),
   declaration: CreatorDeclarationSchema,
   published_version: VersionNumber.nullable(),
-  latest_version: z23.object({
+  latest_version: z26.object({
     version: VersionNumber,
     status: CreatorTemplateVersionStatusSchema
   }).nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreatorTemplateVersionSchema = z23.object({
-  object: z23.literal("creator_template_version"),
+var CreatorTemplateVersionSchema = z26.object({
+  object: z26.literal("creator_template_version"),
   template_id: idOf("ctp"),
   version: VersionNumber,
   declaration: CreatorDeclarationSchema,
   status: CreatorTemplateVersionStatusSchema,
-  note: z23.string().nullable(),
+  note: z26.string().nullable(),
   artifact_id: idOf("bpa").nullable(),
   submitted_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var CreatorBalanceSchema = z23.object({
-  object: z23.literal("creator_balance"),
+var CreatorBalanceSchema = z26.object({
+  object: z26.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: z23.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
+  minimum_payout_micro_usd: z26.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
 });
-var ReferralClickSchema = z23.object({
-  object: z23.literal("referral_click"),
+var ReferralClickSchema = z26.object({
+  object: z26.literal("referral_click"),
   code: CreatorCodeSchema,
-  creator: z23.object({ display_name: z23.string().min(1) }),
+  creator: z26.object({ display_name: z26.string().min(1) }),
   expires_at: Timestamp
 });
-var Day = z23.iso.date();
-var CreatorAnalyticsSchema = z23.object({
-  object: z23.literal("creator_analytics"),
-  days: z23.number().int().min(1).max(90),
-  from: Day,
-  to: Day,
-  clicks: z23.number().int().nonnegative(),
-  referrals: z23.number().int().nonnegative(),
-  installs: z23.number().int().nonnegative(),
-  active_installs: z23.number().int().nonnegative(),
-  usage_by_day: z23.array(
-    z23.object({ day: Day, debit_micro_usd: MicroUsdField.nonnegative() })
+var Day2 = z26.iso.date();
+var CreatorAnalyticsSchema = z26.object({
+  object: z26.literal("creator_analytics"),
+  days: z26.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: z23.object({
+  commission_micro_usd: z26.object({
     pending: MicroUsdField.nonnegative(),
     available: MicroUsdField.nonnegative(),
     claimed: MicroUsdField.nonnegative(),
     paid: MicroUsdField.nonnegative()
   }),
-  commissions_by_template: z23.array(
-    z23.object({
+  commissions_by_template: z26.array(
+    z26.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: z23.array(z23.object({ install_id: idOf("bpi"), from: Day, until: Day }))
+  install_windows: z26.array(z26.object({ install_id: idOf("bpi"), from: Day2, until: Day2 }))
 });
 
 // ../core/src/schema/legal.ts
-import { z as z24 } from "zod";
+import { z as z27 } from "zod";
 var LEGAL_MEMBER_STATUSES = [
   "pending",
   "link_ready",
@@ -2263,16 +2708,16 @@ var LEGAL_MEMBER_STATUSES = [
   "verified",
   "failed"
 ];
-var LegalMemberStatusSchema = z24.enum(LEGAL_MEMBER_STATUSES);
+var LegalMemberStatusSchema = z27.enum(LEGAL_MEMBER_STATUSES);
 var LEGAL_VERIFICATION_STATUSES = ["in_progress", "pending_review", "verified", "failed"];
-var LegalVerificationStatusSchema = z24.enum(LEGAL_VERIFICATION_STATUSES);
+var LegalVerificationStatusSchema = z27.enum(LEGAL_VERIFICATION_STATUSES);
 var LEGAL_COMPANY_STATUSES = ["awaiting_payment", "paid", "submitted", "formed", "failed"];
-var LegalCompanyStatusSchema = z24.enum(LEGAL_COMPANY_STATUSES);
+var LegalCompanyStatusSchema = z27.enum(LEGAL_COMPANY_STATUSES);
 var LEGAL_DOCUMENT_KINDS = ["articles", "ein_letter", "operating_agreement", "other"];
-var LegalDocumentKindSchema = z24.enum(LEGAL_DOCUMENT_KINDS);
-var LegalMemberRoleSchema = z24.enum(["primary", "secondary"]);
-var LegalEinStatusSchema = z24.enum(["none", "pending", "issued"]);
-var LegalRequiredActionKindSchema = z24.enum(["signature", "information", "payment", "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 US_STATES = [
   "AL",
   "AK",
@@ -2326,105 +2771,105 @@ var US_STATES = [
   "WI",
   "WY"
 ];
-var UsStateSchema = z24.enum(US_STATES);
-var LegalMemberInputSchema = z24.object({
-  first_name: z24.string().min(1).max(128),
-  last_name: z24.string().min(1).max(128),
-  email: z24.string().min(1).max(320),
+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),
   role: LegalMemberRoleSchema,
-  is_responsible_party: z24.boolean(),
-  ownership_percent: z24.number().int()
+  is_responsible_party: z27.boolean(),
+  ownership_percent: z27.number().int()
 });
 var LegalMemberSchema = LegalMemberInputSchema.extend({
   id: idOf("lgm"),
-  object: z24.literal("legal_member"),
+  object: z27.literal("legal_member"),
   verification_id: idOf("lgv"),
   status: LegalMemberStatusSchema,
-  link_url: z24.url().nullable(),
+  link_url: z27.url().nullable(),
   link_expires_at: Timestamp.nullable(),
   completed_at: Timestamp.nullable()
 });
-var LegalVerificationSchema = z24.object({
+var LegalVerificationSchema = z27.object({
   id: idOf("lgv"),
-  object: z24.literal("legal_verification"),
+  object: z27.literal("legal_verification"),
   identity_id: idOf("idn"),
   status: LegalVerificationStatusSchema,
-  members: z24.array(LegalMemberSchema),
-  ready_for_formation: z24.boolean(),
+  members: z27.array(LegalMemberSchema),
+  ready_for_formation: z27.boolean(),
   started_at: Timestamp,
   completed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var StartLegalVerificationSchema = z24.object({ members: z24.array(LegalMemberInputSchema) });
-var CompleteLegalMemberSchema = z24.object({ token: z24.string().min(1) });
-var LegalNameOptionSchema = z24.object({ name: z24.string().min(1).max(200), ending: z24.literal("LLC") });
-var LegalMailingAddressSchema = z24.object({
-  line1: z24.string().min(1).max(200),
-  line2: z24.string().max(200).nullable(),
-  city: z24.string().min(1).max(100),
+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),
   state: UsStateSchema,
-  postal_code: z24.string().min(1).max(16),
-  country: z24.literal("US")
+  postal_code: z27.string().min(1).max(16),
+  country: z27.literal("US")
 });
-var LegalRequiredActionSchema = z24.object({
+var LegalRequiredActionSchema = z27.object({
   kind: LegalRequiredActionKindSchema,
-  description: z24.string(),
-  url: z24.url().nullable()
+  description: z27.string(),
+  url: z27.url().nullable()
 });
 var LEGAL_DESCRIPTION_MAX = 50;
-var CreateLegalCompanySchema = z24.object({
+var CreateLegalCompanySchema = z27.object({
   verification_id: idOf("lgv"),
   state: UsStateSchema,
-  name_options: z24.array(z24.string().min(1).max(200)).min(1).max(3),
-  naics_code: z24.string().regex(/^\d{2,6}$/),
-  description: z24.string().min(1).max(LEGAL_DESCRIPTION_MAX),
+  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),
   mailing_address: LegalMailingAddressSchema
 });
 var LegalCompanySchema = CreateLegalCompanySchema.omit({ name_options: true }).extend({
   id: idOf("lgc"),
-  object: z24.literal("legal_company"),
+  object: z27.literal("legal_company"),
   identity_id: idOf("idn"),
   status: LegalCompanyStatusSchema,
-  entity_type: z24.literal("llc"),
-  name_options: z24.array(LegalNameOptionSchema),
-  legal_name: z24.string().nullable(),
+  entity_type: z27.literal("llc"),
+  name_options: z27.array(LegalNameOptionSchema),
+  legal_name: z27.string().nullable(),
   ein_status: LegalEinStatusSchema,
   price_micro_usd: MicroUsdField,
-  required_actions: z24.array(LegalRequiredActionSchema),
-  failure_reason: z24.string().max(256).nullable(),
+  required_actions: z27.array(LegalRequiredActionSchema),
+  failure_reason: z27.string().max(256).nullable(),
   submitted_at: Timestamp.nullable(),
   formed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var LegalDocumentSchema = z24.object({
+var LegalDocumentSchema = z27.object({
   id: idOf("lgd"),
-  object: z24.literal("legal_document"),
+  object: z27.literal("legal_document"),
   company_id: idOf("lgc"),
   kind: LegalDocumentKindSchema,
-  name: z24.string(),
+  name: z27.string(),
   created_at: Timestamp
 });
-var LegalDocumentLinkSchema = z24.object({
-  object: z24.literal("legal_document_link"),
-  url: z24.url(),
+var LegalDocumentLinkSchema = z27.object({
+  object: z27.literal("legal_document_link"),
+  url: z27.url(),
   expires_at: Timestamp
 });
-var NaicsCodeSchema = z24.object({
-  object: z24.literal("naics_code"),
-  code: z24.string().regex(/^\d{2,6}$/),
-  title: z24.string()
+var NaicsCodeSchema = z27.object({
+  object: z27.literal("naics_code"),
+  code: z27.string().regex(/^\d{2,6}$/),
+  title: z27.string()
 });
-var LegalStateSchema = z24.object({
-  object: z24.literal("legal_state"),
+var LegalStateSchema = z27.object({
+  object: z27.literal("legal_state"),
   code: UsStateSchema,
-  name: z24.string(),
+  name: z27.string(),
   formation_fee_micro_usd: MicroUsdField
 });
-var LegalWebhookEventSchema = z24.object({
-  provider_session_ref: z24.string().min(1),
-  status: z24.enum(["verified", "failed", "pending_review"]),
+var LegalWebhookEventSchema = z27.object({
+  provider_session_ref: z27.string().min(1),
+  status: z27.enum(["verified", "failed", "pending_review"]),
   metadata: Metadata
 });
 var LLC_ENDING = /\s*(?:,\s*)?(?:l\.?l\.?c\.?|limited\s+liability\s+company)\s*$/i;
@@ -2435,237 +2880,441 @@ function canonicalName(raw) {
 }
 
 // ../core/src/schema/wallet.ts
-import { z as z25 } from "zod";
+import { z as z28 } from "zod";
 var WALLET_NETWORKS = ["eip155:84532", "eip155:8453"];
-var WalletNetworkSchema = z25.enum(WALLET_NETWORKS);
+var WalletNetworkSchema = z28.enum(WALLET_NETWORKS);
 var DEFAULT_WALLET_NETWORK = "eip155:84532";
-var WalletSelectSchema = z25.object({ network: WalletNetworkSchema.optional() });
+var WalletSelectSchema = z28.object({ network: WalletNetworkSchema.optional() });
 var WALLET_STATUSES = ["active", "frozen", "swept"];
-var WalletStatusSchema = z25.enum(WALLET_STATUSES);
+var WalletStatusSchema = z28.enum(WALLET_STATUSES);
 var WALLET_TRANSACTION_KINDS = ["fund", "transfer", "pay", "sweep"];
-var WalletTransactionKindSchema = z25.enum(WALLET_TRANSACTION_KINDS);
+var WalletTransactionKindSchema = z28.enum(WALLET_TRANSACTION_KINDS);
 var WALLET_TRANSACTION_STATUSES = ["pending", "confirmed", "failed"];
-var WalletTransactionStatusSchema = z25.enum(WALLET_TRANSACTION_STATUSES);
-var WalletDirectionSchema = z25.enum(["in", "out"]);
-var WalletFundSourceSchema = z25.enum(["faucet", "treasury"]);
-var EvmAddressSchema = z25.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x address");
-var TxHashSchema = z25.string().regex(/^0x[0-9a-fA-F]{64}$/, "expected a 0x transaction hash");
-var WalletPolicySchema = z25.object({
+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({
   per_tx_cap_micro_usd: MicroUsdField.nonnegative(),
   daily_cap_micro_usd: MicroUsdField.positive().nullable(),
   low_balance_micro_usd: MicroUsdField.nonnegative().nullable()
 });
-var WalletSchema = z25.object({
+var WalletSchema = z28.object({
   id: idOf("wlt"),
-  object: z25.literal("wallet"),
+  object: z28.literal("wallet"),
   identity_id: idOf("idn"),
   status: WalletStatusSchema,
   network: WalletNetworkSchema,
   address: EvmAddressSchema,
-  asset: z25.literal("usdc"),
+  asset: z28.literal("usdc"),
   balance_micro_usd: MicroUsdField,
   policy: WalletPolicySchema,
   spent_today_micro_usd: MicroUsdField,
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreateWalletSchema = z25.object({
+var CreateWalletSchema = z28.object({
   network: WalletNetworkSchema.optional(),
   policy: WalletPolicySchema.partial().optional()
 });
 var UpdateWalletPolicySchema = WalletPolicySchema.partial();
-var FundWalletSchema = z25.object({
+var FundWalletSchema = z28.object({
   amount_micro_usd: MicroUsdField.positive(),
   source: WalletFundSourceSchema
 });
-var TransferWalletSchema = z25.object({
-  to: z25.union([EvmAddressSchema, idOf("idn")]),
+var TransferWalletSchema = z28.object({
+  to: z28.union([EvmAddressSchema, idOf("idn")]),
   amount_micro_usd: MicroUsdField.positive(),
-  purpose: z25.string().min(1).max(256)
+  purpose: z28.string().min(1).max(256)
 });
-var SweepWalletSchema = z25.object({ to: EvmAddressSchema.optional() });
-var WalletTransactionSchema = z25.object({
+var SweepWalletSchema = z28.object({ to: EvmAddressSchema.optional() });
+var WalletTransactionSchema = z28.object({
   id: idOf("wtx"),
-  object: z25.literal("wallet_transaction"),
+  object: z28.literal("wallet_transaction"),
   wallet_id: idOf("wlt"),
   kind: WalletTransactionKindSchema,
   direction: WalletDirectionSchema,
   amount_micro_usd: MicroUsdField,
-  counterparty: z25.string().nullable(),
-  origin: z25.string().nullable(),
-  purpose: z25.string().nullable(),
+  counterparty: z28.string().nullable(),
+  origin: z28.string().nullable(),
+  purpose: z28.string().nullable(),
   tx_hash: TxHashSchema.nullable(),
   session_id: idOf("ses").nullable(),
   status: WalletTransactionStatusSchema,
   created_at: Timestamp
 });
-var ListWalletTransactionsSchema = z25.object({
+var ListWalletTransactionsSchema = z28.object({
   kind: WalletTransactionKindSchema.optional(),
   direction: WalletDirectionSchema.optional(),
-  origin: z25.string().optional(),
+  origin: z28.string().optional(),
   since: Timestamp.optional()
 });
-var HttpMethodSchema = z25.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-var WalletQuoteRequestSchema = z25.object({ url: z25.url(), method: HttpMethodSchema.optional() });
-var WalletQuoteSchema = z25.object({
-  object: z25.literal("wallet_quote"),
-  url: z25.url(),
-  payable: z25.boolean(),
+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(),
   network: WalletNetworkSchema.nullable(),
-  asset: z25.literal("usdc").nullable(),
+  asset: z28.literal("usdc").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
   pay_to: EvmAddressSchema.nullable(),
-  description: z25.string().nullable(),
-  max_timeout_seconds: z25.number().int().nullable()
+  description: z28.string().nullable(),
+  max_timeout_seconds: z28.number().int().nullable()
 });
 var WalletPayRequestSchema = WalletQuoteRequestSchema.extend({
   max_amount_micro_usd: MicroUsdField.positive().optional()
 });
 var WALLET_RESPONSE_BODY_MAX = 64 * 1024;
-var WalletPaymentSchema = z25.object({
-  object: z25.literal("wallet_payment"),
-  paid: z25.boolean(),
+var WalletPaymentSchema = z28.object({
+  object: z28.literal("wallet_payment"),
+  paid: z28.boolean(),
   transaction_id: idOf("wtx").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
-  response_status: z25.number().int(),
-  response_body: z25.string().max(WALLET_RESPONSE_BODY_MAX)
+  response_status: z28.number().int(),
+  response_body: z28.string().max(WALLET_RESPONSE_BODY_MAX)
 });
 
 // ../core/src/schema/cards.ts
-import { z as z26 } from "zod";
+import { z as z29 } from "zod";
 var CARD_STATUSES = ["pending_payment", "issuing", "active", "failed", "cancelled", "refunded"];
-var CardStatusSchema = z26.enum(CARD_STATUSES);
+var CardStatusSchema = z29.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 = z26.object({
+var CardSchema = z29.object({
   id: idOf("vcd"),
-  object: z26.literal("card"),
+  object: z29.literal("card"),
   identity_id: idOf("idn"),
-  kind: z26.literal("prepaid"),
+  kind: z29.literal("prepaid"),
   status: CardStatusSchema,
-  label: z26.string().min(1).max(128),
-  brand: z26.string().nullable(),
-  last4: z26.string().regex(/^\d{4}$/).nullable(),
+  label: z29.string().min(1).max(128),
+  brand: z29.string().nullable(),
+  last4: z29.string().regex(/^\d{4}$/).nullable(),
   load_micro_usd: MicroUsdField,
   spent_micro_usd: MicroUsdField,
-  currency: z26.literal("usd"),
+  currency: z29.literal("usd"),
   expires_at: Timestamp.nullable(),
-  failure_reason: z26.string().max(256).nullable(),
+  failure_reason: z29.string().max(256).nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var IssueCardSchema = z26.object({
+var IssueCardSchema = z29.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 = z26.object({
-  object: z26.literal("card_quote"),
+var CardQuoteSchema = z29.object({
+  object: z29.literal("card_quote"),
   load_micro_usd: MicroUsdField,
   price_micro_usd: MicroUsdField,
-  brand: z26.string().nullable(),
+  brand: z29.string().nullable(),
   min_load_micro_usd: MicroUsdField,
   max_load_micro_usd: MicroUsdField
 });
-var CardCredentialsSchema = z26.object({
-  object: z26.literal("card_credentials"),
+var CardCredentialsSchema = z29.object({
+  object: z29.literal("card_credentials"),
   card_id: idOf("vcd"),
-  number: z26.string().min(1),
-  pin: z26.string().nullable(),
-  cvv: z26.string().nullable(),
-  expiry: z26.string().nullable(),
-  url: z26.url().nullable(),
-  instructions: z26.string().nullable(),
+  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(),
   revealed_at: Timestamp
 });
-var CardTransactionSchema = z26.object({
+var CardTransactionSchema = z29.object({
   id: idOf("vct"),
-  object: z26.literal("card_transaction"),
+  object: z29.literal("card_transaction"),
   card_id: idOf("vcd"),
   amount_micro_usd: MicroUsdField,
-  merchant: z26.string().nullable(),
-  description: z26.string().nullable(),
+  merchant: z29.string().nullable(),
+  description: z29.string().nullable(),
   session_id: idOf("ses").nullable(),
   metadata: Metadata,
   created_at: Timestamp
 });
-var LogCardTransactionSchema = z26.object({
+var LogCardTransactionSchema = z29.object({
   amount_micro_usd: MicroUsdField.positive(),
-  merchant: z26.string().max(256).optional(),
-  description: z26.string().max(1024).optional(),
+  merchant: z29.string().max(256).optional(),
+  description: z29.string().max(1024).optional(),
   metadata: Metadata.optional()
 });
-var ListCardsSchema = z26.object({ status: CardStatusSchema.optional() });
+var ListCardsSchema = z29.object({ status: CardStatusSchema.optional() });
 
 // ../core/src/schema/proxy-trace.ts
-import { z as z27 } from "zod";
-var ProxyDialectSchema = z27.enum(["anthropic", "openai"]);
-var ProxyTraceContentScopeSchema = z27.enum(["full", "metadata"]);
-var ProxyTraceRequestSchema = z27.object({
-  system: z27.string(),
-  messages: z27.array(z27.object({ role: z27.string(), content: z27.string() })),
-  tool_names: z27.array(z27.string())
-});
-var ProxyTraceResponseSchema = z27.object({
-  text: z27.string(),
-  tool_calls: z27.array(z27.object({ name: z27.string(), arguments: z27.string() }))
-});
-var Sha256 = z27.string().regex(/^[0-9a-f]{64}$/);
-var ProxyCallTraceSchema = z27.object({
+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(),
+  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()
+    })
+  ),
+  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),
+  /** A call that threw, was abandoned or never completed (ADR-0794): the reply is what streamed before. */
+  is_error: z30.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()
+});
+var Sha256 = z30.string().regex(/^[0-9a-f]{64}$/);
+var ProxyCallTraceSchema = z30.object({
   /** The request id: also `x-request-id`, the reply's `id`, and the ledger entry's idempotency key. */
   id: idOf("req"),
-  object: z27.literal("proxy_call_trace"),
+  object: z30.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: z27.string(),
+  model: z30.string(),
   window: WindowSchema,
   /** The model the reply said served it — where `vetta/auto` resolves — or null if it named none. */
-  resolved_model: z27.string().nullable(),
+  resolved_model: z30.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: z27.string().nullable(),
-  generation_id: z27.string().nullable(),
-  stop: z27.enum(["end_turn", "tool_use", "length"]).nullable(),
+  provider: z30.string().nullable(),
+  generation_id: z30.string().nullable(),
+  stop: z30.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: z27.number().int().nonnegative().nullable(),
+  duration_ms: z30.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"]),
+  /** The session the call belongs to: a harness call's, or a sandbox token's `sub` on the proxy. */
+  session_id: z30.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(),
+  /** The board card the session was woken for (`session.metadata.board.card_id`), or null. */
+  board_card_id: z30.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()),
+  /** 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 size of each body BEFORE any cap, so a truncated row still reports what was really sent. */
-  request_bytes: z27.number().int().nonnegative(),
-  response_bytes: z27.number().int().nonnegative(),
-  /** Null whenever `content_scope` is `metadata`. */
+  /** The UTF-8 size of each stored body. */
+  request_bytes: z30.number().int().nonnegative(),
+  response_bytes: z30.number().int().nonnegative(),
+  /** Inline in `full` scope — every new row. Null on a legacy `metadata` or `object` row. */
   request: ProxyTraceRequestSchema.nullable(),
   response: ProxyTraceResponseSchema.nullable(),
-  truncated: z27.boolean(),
+  /** Always false since ADR-0762 (nothing is cut); true only on rows from before it. */
+  truncated: z30.boolean(),
   created_at: Timestamp,
-  /** When the reaper deletes this row. Never null: there is no row that is kept forever. */
-  expires_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({
+  decision: ReviewDecisionSchema,
+  reason: z31.string().max(4e3).nullable().optional(),
+  file_ids: z31.array(idOf("fil")).max(50).optional(),
+  session_id: idOf("ses").optional(),
+  subject: z31.record(z31.string().max(100), z31.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/session-token.ts
+var SESSION_TTL_SECONDS = 30 * 24 * 60 * 60;
+var encoder = new TextEncoder();
+
+// ../core/src/logo-svg.ts
+var MAX_BYTES = 16 * 1024;
+
 // ../core/src/file-url.ts
 var encoder2 = new TextEncoder();
 var SESSION_FILE_URL_TTL_MS = 15 * 6e4;
 
 // src/define.ts
-import { z as z30 } from "zod";
+import { z as z35 } from "zod";
 
 // src/roster.ts
-import { z as z29 } from "zod";
+import { z as z34 } from "zod";
 
 // src/report.ts
 import { ApiError, send } from "@usenaive-sdk/vetta";
-import { z as z28 } from "zod";
+import { z as z33 } 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);
@@ -2707,15 +3356,15 @@ async function absent(work) {
     throw error;
   }
 }
-var PageShape = z28.object({
-  data: z28.array(z28.unknown()),
-  has_more: z28.boolean(),
-  next_cursor: z28.string().nullable()
+var PageShape = z33.object({
+  data: z33.array(z33.unknown()),
+  has_more: z33.boolean(),
+  next_cursor: z33.string().nullable()
 });
 function rowLabel(row) {
   const { object, id } = row ?? {};
-  const words = [object, id].filter((one) => typeof one === "string");
-  return words.length > 0 ? words.join(" ") : "a row";
+  const words2 = [object, id].filter((one) => typeof one === "string");
+  return words2.length > 0 ? words2.join(" ") : "a row";
 }
 var why = (error) => error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
 async function listAll(config, path, item, skipped, query = {}) {
@@ -2742,17 +3391,17 @@ async function tombstone(name, current, remove, dryRun) {
 }
 
 // src/roster.ts
-var NAME = z29.string().min(1);
-var RosterNameSchema = z29.union([
+var NAME = z34.string().min(1);
+var RosterNameSchema = z34.union([
   NAME.transform((name) => ({ type: "agent", name })),
-  z29.object({ type: z29.literal("agent"), name: NAME, version: z29.number().int().positive().optional() }),
-  z29.object({ type: z29.literal("self") }),
-  z29.object({ type: z29.literal("advisor"), model: z29.string().min(1) })
+  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) })
 ]);
-var DeclMultiagentField = z29.union([
-  z29.boolean(),
-  z29.object({ ...MultiagentSchema.shape, agents: z29.array(RosterNameSchema).min(1).max(20) }),
-  z29.null()
+var DeclMultiagentField = z34.union([
+  z34.boolean(),
+  z34.object({ ...MultiagentSchema.shape, agents: z34.array(RosterNameSchema).min(1).max(20) }),
+  z34.null()
 ]);
 var hasRoster = (value) => typeof value === "object" && value !== null;
 var rosterNames = (roster) => roster.agents.flatMap((entry) => entry.type === "agent" ? [entry.name] : []);
@@ -2809,8 +3458,14 @@ var BLUEPRINTS = {
    * 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"] },
+  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" }
 };
@@ -2844,65 +3499,65 @@ function chooseTemplate(blueprint, template) {
 var BlueprintRefusal = class extends Error {
   name = "BlueprintRefusal";
 };
-var EnvValueSchema = z30.union([
-  z30.string(),
-  z30.object({ from_env: z30.string().min(1) }),
-  z30.object({ generate: z30.literal(true) })
+var EnvValueSchema = z35.union([
+  z35.string(),
+  z35.object({ from_env: z35.string().min(1) }),
+  z35.object({ generate: z35.literal(true) })
 ]);
-var AppDeclSchema = z30.object({
+var AppDeclSchema = z35.object({
   /** Becomes a hostname, so the grammar is the platform's `APP_NAME` (a DNS label). */
-  name: z30.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
+  name: z35.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
   type: AppTypeSchema,
-  description: z30.string().optional(),
+  description: z35.string().optional(),
   /** A directory whose files are collected and shipped as the app's file-map deployment. */
-  deploy_dir: z30.string().min(1).optional(),
+  deploy_dir: z35.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: z30.record(z30.string().regex(ENV_NAME), EnvValueSchema, { error: "keyed by environment variable name (A-Z, 0-9, _)" }).optional(),
+  env: z35.record(z35.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: z30.boolean().optional(),
+  required: z35.boolean().optional(),
   // core-gaps: U8-database
   /** SQL files applied in order to the app's database after it is provisioned (§37); `fullstack` only. */
-  migrations: z30.array(z30.string().min(1)).optional(),
+  migrations: z35.array(z35.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: z30.array(CreateBucketSchema).optional()
+  buckets: z35.array(CreateBucketSchema).optional()
 });
-var ScheduleDeclSchema = z30.object({
-  cron: z30.string().min(1),
-  timezone: z30.string().min(1).optional(),
+var ScheduleDeclSchema = z35.object({
+  cron: z35.string().min(1),
+  timezone: z35.string().min(1).optional(),
   /** The message every fire opens its session with (`input_template` on the wire). */
-  input: z30.string().min(1),
+  input: z35.string().min(1),
   budget_micro_usd: MicroUsdField.nonnegative(),
-  identity: z30.string().min(1).optional(),
-  enabled: z30.boolean().optional()
+  identity: z35.string().min(1).optional(),
+  enabled: z35.boolean().optional()
 });
 var ToolsDeclSchema = ToolsetSchema;
-var AgentDeclSchema = z30.object({
-  name: z30.string().min(1),
-  model: z30.string().min(1),
+var AgentDeclSchema = z35.object({
+  name: z35.string().min(1),
+  model: z35.string().min(1),
   budget: BudgetSchema,
-  description: z30.string().optional(),
+  description: z35.string().optional(),
   /** Two or three words the studio prints beside the name (§31.5) — "Head of content", not a sentence. */
-  role: z30.string().min(1).optional(),
+  role: z35.string().min(1).optional(),
   /** An install may not leave this agent out of its `selection` (§31.2). Absent means it may. */
-  required: z30.boolean().optional(),
-  system: z30.string().optional(),
+  required: z35.boolean().optional(),
+  system: z35.string().optional(),
   tools: ToolsDeclSchema.optional(),
-  skills: z30.array(SkillRefSchema).optional(),
-  mcp_servers: z30.array(McpServerSchema).optional(),
+  skills: z35.array(SkillRefSchema).optional(),
+  mcp_servers: z35.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: z30.boolean().optional(),
+  structured_output_required: z35.boolean().optional(),
   metadata: Metadata.optional(),
   /** Declared app *names*; `up` resolves them to `app_` ids in `tools.configs.apps` (§29.3). */
-  allowed_apps: z30.array(z30.string()).optional(),
+  allowed_apps: z35.array(z35.string()).optional(),
   /** A declared identity *name*; `up` attaches it after the agent upsert (§22). */
-  identity: z30.string().min(1).optional(),
+  identity: z35.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
@@ -2910,7 +3565,7 @@ var AgentDeclSchema = z30.object({
    */
   handoffs: HandoffsField.optional(),
   /** The agent's deployments as a complete set: declared → owned, and the rest are pruned (ADR-0355). */
-  schedules: z30.array(ScheduleDeclSchema).optional(),
+  schedules: z35.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.
@@ -2923,66 +3578,79 @@ var AgentDeclSchema = z30.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: z30.object({ message: z30.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
+  intake: z35.object({ message: z35.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
 });
-var CredentialDeclSchema = z30.object({
+var CredentialDeclSchema = z35.object({
   kind: VaultCredentialKindSchema,
-  key: z30.string().min(1).max(128),
+  key: z35.string().min(1).max(128),
   /** The one exact destination host an `env_var` is bound to. */
-  host: z30.string().min(1).optional(),
+  host: z35.string().min(1).optional(),
   /** The MCP server URL a `static_bearer` / `mcp_oauth` token is matched to. */
-  mcp_server_url: z30.url().optional(),
-  value: z30.object({ from_env: z30.string().min(1) })
+  mcp_server_url: z35.url().optional(),
+  value: z35.object({ from_env: z35.string().min(1) })
 });
-var VaultDeclSchema = z30.object({
+var VaultDeclSchema = z35.object({
   name: VaultSchema.shape.display_name,
-  identity: z30.string().min(1).optional(),
-  credentials: z30.array(CredentialDeclSchema)
+  identity: z35.string().min(1).optional(),
+  credentials: z35.array(CredentialDeclSchema)
 });
-var SkillDeclSchema = z30.object({
-  slug: z30.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  file: z30.string().min(1)
+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 LegalDeclSchema = CreateLegalCompanySchema.pick({
   state: true,
   name_options: true,
   naics_code: true,
   description: true
-}).extend({ label: z30.string().min(1).max(128) });
+}).extend({ label: z35.string().min(1).max(128) });
 var WalletDeclSchema = CreateWalletSchema.or(
-  z30.array(CreateWalletSchema).refine(
+  z35.array(CreateWalletSchema).refine(
     (list2) => new Set(list2.map((w) => w.network ?? DEFAULT_WALLET_NETWORK)).size === list2.length,
     { message: "one wallet per network" }
   )
 );
 var CardDeclSchema = IssueCardSchema;
 var IdentityDeclSchema = IdentitySchema.pick({ name: true, description: true }).partial({ description: true }).extend({
-  connections: BlueprintIdentityConnectionsSchema.optional(),
-  legal: z30.array(LegalDeclSchema).optional(),
+  legal: z35.array(LegalDeclSchema).optional(),
   wallet: WalletDeclSchema.optional(),
-  cards: z30.array(CardDeclSchema).optional()
-});
-var RemovedSchema = z30.object({
-  apps: z30.array(z30.string().min(1)).default([]),
-  agents: z30.array(z30.string().min(1)).default([]),
-  skills: z30.array(z30.string().min(1)).default([]),
-  identities: z30.array(z30.string().min(1)).default([]),
-  vaults: z30.array(z30.string().min(1)).default([])
-});
-var KeptSchema = z30.object({ agents: z30.array(z30.string().min(1)).default([]) });
-var TaskDeclSchema = z30.object({
-  key: z30.string().min(1),
-  title: z30.string().min(1).max(200),
-  body: z30.string().max(8192).optional(),
-  assignee: z30.string().min(1).optional(),
-  blocked_by: z30.array(z30.string().min(1)).optional()
-});
-var ProjectSchema = z30.object({
-  name: z30.string().min(1),
+  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),
   /** The machine this project runs: its repo, its screens, its `/api/*` (`template.ts`). */
-  blueprint: z30.string().min(1).optional(),
+  blueprint: z35.string().min(1).optional(),
   /** Which of that blueprint's templates provides the crew; a blueprint with a default may omit it. */
-  template: z30.string().min(1).optional(),
+  template: z35.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(),
+  /**
+   * 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
+   * studio draws every one with one general UI, under Apps.
+   */
+  mini_apps: MiniAppDeclsSchema.optional(),
   /**
    * What a person is asked BEFORE the crew is provisioned (`canonical-spec §31.2`).
    *
@@ -2994,21 +3662,21 @@ var ProjectSchema = z30.object({
    *
    * **Configuration only.** A secret is a vault credential or an app secret; neither is an answer.
    */
-  questions: z30.array(QuestionFieldSchema).default([]),
-  skills: z30.array(SkillDeclSchema).default([]),
-  identities: z30.array(IdentityDeclSchema).default([]),
-  vaults: z30.array(VaultDeclSchema).default([]),
-  apps: z30.array(AppDeclSchema).default([]),
-  agents: z30.array(AgentDeclSchema).default([]),
+  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([]),
   /**
    * 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: z30.array(z30.object({ name: z30.string().min(1), role: z30.string().min(1).optional(), description: z30.string().optional() })).optional(),
+  crew_per_client: z35.array(z35.object({ name: z35.string().min(1), role: z35.string().min(1).optional(), description: z35.string().optional() })).optional(),
   /** The crew's first work, as cards on the organization's board rather than N private intakes (§31.11). */
-  tasks: z30.array(TaskDeclSchema).default([]),
+  tasks: z35.array(TaskDeclSchema).default([]),
   removed: RemovedSchema.default({ apps: [], agents: [], skills: [], identities: [], vaults: [] }),
   kept: KeptSchema.default({ agents: [] })
 });
@@ -3063,8 +3731,8 @@ function parseProject(input) {
   }
   const config = parsed.data;
   applyChoice(config);
-  if (config.template !== void 0 && config.questions.length > 4) {
-    refuse(`template "${config.template}" asks ${config.questions.length} questions, but a template asks at most 4 before anything is provisioned \u2014 a fifth belongs to the crew's first conversation`);
+  if (config.template !== void 0 && config.questions.length > TEMPLATE_QUESTIONS_MAX) {
+    refuse(`template "${config.template}" asks ${config.questions.length} questions, but a template asks at most ${TEMPLATE_QUESTIONS_MAX} before anything is provisioned \u2014 a fifth belongs to the crew's first conversation`);
   }
   assertUniqueNames("app", [...config.apps.map((a) => a.name), ...config.removed.apps]);
   assertUniqueNames("agent", [...config.agents.map((a) => a.name), ...config.removed.agents, ...config.kept.agents]);
@@ -3085,20 +3753,6 @@ function parseProject(input) {
     assertUniqueNames("bucket", (app.buckets ?? []).map((bucket) => bucket.name));
   }
   const identityNames = new Set(config.identities.map((i) => i.name));
-  const connectable = config.identities.filter((i) => i.connections !== void 0).map((i) => i.name);
-  if (connectable.length > 1) {
-    refuse(`identities ${connectable.map((n) => `"${n}"`).join(", ")} each declare connections, but the studio's Add connections step connects one persona \u2014 declare connections on the one the crew publishes through`);
-  }
-  for (const identity of config.identities) {
-    const social = identity.connections?.social;
-    if (social === void 0) continue;
-    const question = config.questions.find((q) => q.key === social.from);
-    if (question === void 0) refuse(`identity "${identity.name}": connections.social.from names "${social.from}", but no question with that key is declared in this project`);
-    if (question.type !== "choice") refuse(`identity "${identity.name}": connections.social.from names "${social.from}", which is a ${question.type} question \u2014 the map is keyed by a choice question's options`);
-    for (const label of Object.keys(social.map)) {
-      if (!question.options.includes(label)) refuse(`identity "${identity.name}": connections.social.map names "${label}", which is not one of question "${social.from}"'s options \u2014 a key no answer can equal is a row nobody can reach`);
-    }
-  }
   for (const vault of config.vaults) {
     if (vault.identity !== void 0 && !identityNames.has(vault.identity)) {
       refuse(`vault "${vault.name}": identity names "${vault.identity}", but no identity with that name is declared in this project`);
@@ -3309,167 +3963,6 @@ import { createHash as createHash3 } from "node:crypto";
 import { readFileSync as readFileSync4 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 
-// src/agents.ts
-var PROJECT_CONTEXT_PREAMBLE = "Before anything else, read the project context with the `project_context` tool. The answers in it are the client's own \u2014 never invent, assume or restate them from memory; what the context does not say, you ask. Use the context's own words for the company, its offer and its audience.";
-function desiredMetadata(decl, of, current) {
-  if (of.template === void 0) return decl.metadata;
-  return {
-    ...current?.metadata,
-    ...decl.metadata,
-    project: of.project,
-    ...of.blueprint !== void 0 ? { blueprint: of.blueprint } : {},
-    template: of.template,
-    group: of.template
-  };
-}
-function desiredSystem(decl, of) {
-  if (of.template === void 0) return decl.system;
-  return decl.system === void 0 ? PROJECT_CONTEXT_PREAMBLE : `${PROJECT_CONTEXT_PREAMBLE}
-
-${decl.system}`;
-}
-function desiredTools(decl, current, ids) {
-  const handoff = decl.handoffs !== void 0 && handoffsEnabled(decl.handoffs);
-  if (ids === void 0 && !handoff) return decl.tools;
-  const base = decl.tools ?? current?.tools ?? { default_config: { permission: "allow" }, configs: {} };
-  const appsTool = base.configs["apps"] ?? { enabled: true, permission: base.default_config.permission };
-  const allowed = { enabled: true, permission: "allow" };
-  return {
-    default_config: base.default_config,
-    configs: {
-      ...base.configs,
-      ...ids !== void 0 ? { apps: { ...appsTool, config: { ...appsTool.config, allowed_apps: ids } } } : {},
-      ...handoff ? { send_to_agent: allowed, list_agents: allowed } : {}
-    }
-  };
-}
-async function createAgent(client, decl, tools, team, identityId, system, metadata) {
-  const created = await client.agents.create({
-    name: decl.name,
-    model: decl.model,
-    budget: decl.budget,
-    ...decl.description !== void 0 ? { description: decl.description } : {},
-    ...system !== void 0 ? { system } : {},
-    ...decl.skills !== void 0 ? { skills: decl.skills } : {},
-    ...decl.mcp_servers !== void 0 ? { mcp_servers: decl.mcp_servers } : {},
-    ...tools !== void 0 ? { tools } : {},
-    ...decl.window !== void 0 ? { window: decl.window } : {},
-    ...team !== void 0 ? { multiagent: team } : {},
-    ...decl.handoffs !== void 0 ? { handoffs: decl.handoffs } : {},
-    ...decl.output_schema !== void 0 ? { output_schema: decl.output_schema } : {},
-    ...decl.structured_output_required !== void 0 ? { structured_output_required: decl.structured_output_required } : {},
-    ...metadata !== void 0 ? { metadata } : {}
-  });
-  if (identityId !== void 0) await client.identities.attach(created.id, identityId);
-  return { name: decl.name, action: "created", id: created.id };
-}
-async function upsertAgent(client, decl, existing, ids, dryRun, scoped, of) {
-  const unresolved = (decl.allowed_apps ?? []).filter((name) => !ids.apps.has(name));
-  const identityId = decl.identity === void 0 ? void 0 : ids.identities.get(decl.identity);
-  const missing = unresolved.length > 0 ? `allowed_apps needs app "${unresolved[0]}"` : decl.identity !== void 0 && identityId === void 0 ? `identity needs "${decl.identity}"` : null;
-  if (missing !== null && !dryRun) {
-    return { name: decl.name, action: "refused", reason: `${missing}, which was not provisioned in this run` };
-  }
-  const appIds = decl.allowed_apps !== void 0 ? decl.allowed_apps.flatMap((name) => ids.apps.get(name) ?? []) : scoped;
-  const current = existing.find((agent) => agent.name === decl.name) ?? null;
-  const tools = desiredTools(decl, current, appIds);
-  const team = teamWithoutRoster(decl.multiagent);
-  const system = desiredSystem(decl, of);
-  const metadata = desiredMetadata(decl, of, current);
-  if (!current) {
-    return dryRun ? { name: decl.name, action: "created" } : createAgent(client, decl, tools, team, identityId, system, metadata);
-  }
-  const patch = drift(decl, current, tools, team, system, metadata);
-  const held = identityId === void 0 ? [] : (await client.identities.held(current.id)).data;
-  const grant = identityId === void 0 || held.some((one) => one.id === identityId) ? null : identityId;
-  const drifted = Object.keys(patch).length > 0 || missing !== null || grant !== null;
-  if (!drifted) return { name: decl.name, action: "unchanged", id: current.id };
-  if (!dryRun) {
-    if (Object.keys(patch).length > 0) await client.agents.update(current.id, patch);
-    if (grant !== null) await client.identities.attach(current.id, grant);
-  }
-  return { name: decl.name, action: "updated", id: current.id };
-}
-function drift(decl, current, tools, team, system, metadata) {
-  const patch = {};
-  if (changed(decl.model, current.model)) patch.model = decl.model;
-  if (changed(decl.budget, current.budget)) patch.budget = decl.budget;
-  if (changed(decl.description, current.description)) patch.description = decl.description;
-  if (changed(system, current.system)) patch.system = system;
-  if (changed(decl.skills, current.skills)) patch.skills = decl.skills;
-  if (changed(decl.mcp_servers, current.mcp_servers)) patch.mcp_servers = decl.mcp_servers;
-  if (changed(tools, current.tools)) patch.tools = tools;
-  if (changed(decl.window, current.window)) patch.window = decl.window;
-  if (team !== void 0 && changed(normaliseMultiagent(team), normaliseMultiagent(current.multiagent))) patch.multiagent = team;
-  if (changed(decl.handoffs, handoffsOf(current))) patch.handoffs = decl.handoffs;
-  if (changed(decl.output_schema, current.output_schema)) patch.output_schema = decl.output_schema;
-  if (changed(decl.structured_output_required, current.structured_output_required)) patch.structured_output_required = decl.structured_output_required;
-  if (changed(metadata, current.metadata)) patch.metadata = metadata;
-  return patch;
-}
-async function openIntake(client, agent, decl, dryRun) {
-  if (dryRun || agent.id === void 0) return { name: agent.name, action: "created" };
-  const started = await client.sessions.create({
-    agent_id: agent.id,
-    message: decl.message,
-    ...decl.budget_micro_usd !== void 0 ? { budget_micro_usd: decl.budget_micro_usd } : {}
-  });
-  return { name: agent.name, action: "created", id: started.id };
-}
-function brief(input) {
-  const first = input.trim().split(/(?<=[.!?])\s|\n/)[0]?.trim() ?? "";
-  const text = first.replace(/[.\s]+$/, "");
-  return text.length > 72 ? `${text.slice(0, 71).trimEnd()}\u2026` : text;
-}
-async function upsertSchedule(client, agent, decl, current, identityIds, dryRun) {
-  const name = `${agent.name} @ ${decl.cron}`;
-  if (agent.action === "refused") throw new Error(`agent "${agent.name}" was not provisioned in this run`);
-  const identity = decl.identity === void 0 ? void 0 : identityIds.get(decl.identity);
-  const unresolved = decl.identity !== void 0 && identity === void 0;
-  if (unresolved && !dryRun) throw new Error(`identity needs "${decl.identity}", which was not provisioned in this run`);
-  if (!current) {
-    if (dryRun || agent.id === void 0) return { name, action: "created" };
-    const created = await client.deployments.create({
-      agent_id: agent.id,
-      cron: decl.cron,
-      input_template: decl.input,
-      budget_micro_usd: decl.budget_micro_usd,
-      ...decl.timezone !== void 0 ? { timezone: decl.timezone } : {},
-      ...identity !== void 0 ? { identity } : {},
-      ...decl.enabled !== void 0 ? { enabled: decl.enabled } : {}
-    });
-    return { name, action: "created", id: created.id };
-  }
-  const patch = {};
-  if (changed(decl.timezone, current.timezone)) patch.timezone = decl.timezone;
-  if (changed(decl.input, current.input_template)) patch.input_template = decl.input;
-  if (changed(decl.budget_micro_usd, current.budget_micro_usd)) patch.budget_micro_usd = decl.budget_micro_usd;
-  if (changed(identity, current.identity)) patch.identity = identity;
-  if (changed(decl.enabled, current.enabled)) patch.enabled = decl.enabled;
-  if (Object.keys(patch).length === 0 && !unresolved) return { name, action: "unchanged", id: current.id };
-  if (!dryRun) await client.deployments.update(current.id, patch);
-  return { name, action: "updated", id: current.id };
-}
-async function reconcileSchedules(client, agent, declared, live, identityIds, dryRun, into) {
-  const rows = live.filter((row) => row.agent_id === agent.id);
-  into.push(
-    ...await eachInFlight(declared, async (decl) => ({
-      ...await line(
-        `${agent.name} @ ${decl.cron}`,
-        () => upsertSchedule(client, agent, decl, rows.find((row) => row.cron === decl.cron), identityIds, dryRun)
-      ),
-      // `<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)
-    }))
-  );
-  for (const row of rows.filter((row2) => !declared.some((decl) => decl.cron === row2.cron))) {
-    const name = `${agent.name} @ ${row.cron}`;
-    await attempt(into, name, () => tombstone(name, row, (id) => client.deployments.delete(id), dryRun));
-  }
-}
-
 // src/apps.ts
 import { createHash as createHash2, randomBytes } from "node:crypto";
 import { resolve as resolve3 } from "node:path";
@@ -3529,10 +4022,10 @@ async function findApp(client, name, skipped) {
   const rows = await listAll(client.config, "/v1/apps", AppSchema, skipped, { name });
   return rows.find((app) => app.name === name) ?? null;
 }
-function ownershipRefusal(name, project, owner) {
+function ownershipRefusal(name, project, owner, kind = "app") {
   const held = owner === null ? "no project (it was created outside a blueprint)" : `project "${owner}"`;
   const verb = owner === null ? "take" : "transfer";
-  return `app "${name}" is owned by ${held}; this project is "${project}". Rename the app in your config, or re-run \`naive up --adopt\` to ${verb} it.`;
+  return `${kind} "${name}" is owned by ${held}; this project is "${project}". Rename the ${kind} in your config, or re-run \`naive up --adopt\` to ${verb} it.`;
 }
 var ensureApp = (client, body) => client.apps.create(body);
 var PLATFORM_ENV = {
@@ -3636,13 +4129,13 @@ function builtTree(decl, opts) {
   const files = collectFiles(hosted?.[decl.name] ?? resolve3(opts.dir, decl.deploy_dir));
   return { files, hash: contentHash(files) };
 }
-async function writeApp(client, id, env, tree) {
+async function writeApp(client, id, env, tree2) {
   await eachInFlight(
     Object.entries(env),
     ([name, value]) => client.apps.setSecret(id, { name, value, value_hash: secretHash(name, value) })
   );
-  if (!tree) return;
-  await client.apps.deploy(id, tree.files, tree.hash);
+  if (!tree2) return;
+  await client.apps.deploy(id, tree2.files, tree2.hash);
   await settleDeploy(client, id);
 }
 var SETTLE_TRIES = 30;
@@ -3654,7 +4147,7 @@ async function settleDeploy(client, id) {
     await new Promise((resolve5) => setTimeout(resolve5, SETTLE_MS));
   }
 }
-async function createApp(client, decl, env, tree, migrations, opts, appIds) {
+async function createApp(client, decl, env, tree2, migrations, opts, appIds) {
   const created = await ensureApp(client, {
     name: decl.name,
     type: decl.type,
@@ -3663,7 +4156,7 @@ async function createApp(client, decl, env, tree, migrations, opts, appIds) {
     ...decl.mcp !== void 0 ? { mcp: decl.mcp } : {}
   });
   appIds.set(decl.name, created.id);
-  await writeApp(client, created.id, withAppId(env, decl, opts, created.id), tree);
+  await writeApp(client, created.id, withAppId(env, decl, opts, created.id), tree2);
   const notes = [];
   if (migrations.length > 0) notes.push((await applyMigrations(client, created.id, migrations)).note);
   if (decl.buckets !== void 0) notes.push((await applyBuckets(client, created.id, decl.buckets)).note);
@@ -3734,9 +4227,9 @@ async function upsertApp(client, decl, opts, appIds) {
     ...(decl.mcp ?? null) !== current.mcp ? { mcp: decl.mcp ?? null } : {}
   };
   const drifted = Object.keys(patch).length > 0;
-  const tree = builtTree(decl, opts);
-  const newest = tree ? (await client.apps.deployments(current.id, { limit: 1 })).data[0] : void 0;
-  const stale = tree !== null && newest?.content_hash !== tree.hash;
+  const tree2 = builtTree(decl, opts);
+  const newest = tree2 ? (await client.apps.deployments(current.id, { limit: 1 })).data[0] : void 0;
+  const stale = tree2 !== null && newest?.content_hash !== tree2.hash;
   let action = !owned || drifted || stale || staleNames.length > 0 ? "updated" : "unchanged";
   const plan = opts.dryRun ? [
     ...staleNames.length > 0 ? [`will set ${staleNames.join(", ")}`] : [],
@@ -3747,7 +4240,7 @@ async function upsertApp(client, decl, opts, appIds) {
   ] : [];
   if (!opts.dryRun) {
     if (drifted) await client.apps.update(current.id, { ...patch, project: opts.project });
-    await writeApp(client, current.id, staleEnv, stale ? tree : null);
+    await writeApp(client, current.id, staleEnv, stale ? tree2 : null);
     const migrations = declaredMigrations(decl, opts);
     if (migrations.length > 0) {
       const { fresh, note: note2 } = await applyMigrations(client, current.id, migrations);
@@ -3770,6 +4263,172 @@ async function upsertApp(client, decl, opts, appIds) {
   };
 }
 
+// src/agents.ts
+var PROJECT_CONTEXT_PREAMBLE = "Before anything else, read the project context with the `project_context` tool. The answers in it are the client's own \u2014 never invent, assume or restate them from memory; what the context does not say, you ask. Use the context's own words for the company, its offer and its audience.";
+function desiredMetadata(decl, of, current) {
+  if (of.template === void 0) return decl.metadata;
+  return {
+    ...current?.metadata,
+    ...decl.metadata,
+    project: of.project,
+    ...of.blueprint !== void 0 ? { blueprint: of.blueprint } : {},
+    template: of.template,
+    group: of.group ?? of.template
+  };
+}
+function desiredSystem(decl, of) {
+  if (of.template === void 0) return decl.system;
+  return decl.system === void 0 ? PROJECT_CONTEXT_PREAMBLE : `${PROJECT_CONTEXT_PREAMBLE}
+
+${decl.system}`;
+}
+function desiredTools(decl, current, ids) {
+  const handoff = decl.handoffs !== void 0 && handoffsEnabled(decl.handoffs);
+  if (ids === void 0 && !handoff) return decl.tools;
+  const base = decl.tools ?? current?.tools ?? { default_config: { permission: "allow" }, configs: {} };
+  const appsTool = base.configs["apps"] ?? { enabled: true, permission: base.default_config.permission };
+  const allowed = { enabled: true, permission: "allow" };
+  return {
+    default_config: base.default_config,
+    configs: {
+      ...base.configs,
+      ...ids !== void 0 ? { apps: { ...appsTool, config: { ...appsTool.config, allowed_apps: ids } } } : {},
+      ...handoff ? { send_to_agent: allowed, list_agents: allowed } : {}
+    }
+  };
+}
+async function createAgent(client, decl, tools, team, identityId, system, metadata) {
+  const created = await client.agents.create({
+    name: decl.name,
+    model: decl.model,
+    budget: decl.budget,
+    ...decl.description !== void 0 ? { description: decl.description } : {},
+    ...system !== void 0 ? { system } : {},
+    ...decl.skills !== void 0 ? { skills: decl.skills } : {},
+    ...decl.mcp_servers !== void 0 ? { mcp_servers: decl.mcp_servers } : {},
+    ...tools !== void 0 ? { tools } : {},
+    ...decl.window !== void 0 ? { window: decl.window } : {},
+    ...team !== void 0 ? { multiagent: team } : {},
+    ...decl.handoffs !== void 0 ? { handoffs: decl.handoffs } : {},
+    ...decl.output_schema !== void 0 ? { output_schema: decl.output_schema } : {},
+    ...decl.structured_output_required !== void 0 ? { structured_output_required: decl.structured_output_required } : {},
+    ...metadata !== void 0 ? { metadata } : {}
+  });
+  if (identityId !== void 0) await client.identities.attach(created.id, identityId);
+  return { name: decl.name, action: "created", id: created.id };
+}
+async function upsertAgent(client, decl, existing, ids, dryRun, scoped2, of) {
+  const unresolved = (decl.allowed_apps ?? []).filter((name) => !ids.apps.has(name));
+  const identityId = decl.identity === void 0 ? void 0 : ids.identities.get(decl.identity);
+  const missing = unresolved.length > 0 ? `allowed_apps needs app "${unresolved[0]}"` : decl.identity !== void 0 && identityId === void 0 ? `identity needs "${decl.identity}"` : null;
+  if (missing !== null && !dryRun) {
+    return { name: decl.name, action: "refused", reason: `${missing}, which was not provisioned in this run` };
+  }
+  const appIds = decl.allowed_apps !== void 0 ? decl.allowed_apps.flatMap((name) => ids.apps.get(name) ?? []) : scoped2;
+  const current = existing.find((agent) => agent.name === decl.name) ?? null;
+  const owner = typeof current?.metadata?.["project"] === "string" ? current.metadata["project"] : null;
+  if (current && of.template !== void 0 && owner !== null && owner !== of.project && !of.adopt) {
+    return { name: decl.name, action: "refused", id: current.id, reason: ownershipRefusal(decl.name, of.project, owner, "agent") };
+  }
+  const tools = desiredTools(decl, current, appIds);
+  const team = teamWithoutRoster(decl.multiagent);
+  const system = desiredSystem(decl, of);
+  const metadata = desiredMetadata(decl, of, current);
+  if (!current) {
+    return dryRun ? { name: decl.name, action: "created" } : createAgent(client, decl, tools, team, identityId, system, metadata);
+  }
+  const patch = drift(decl, current, tools, team, system, metadata);
+  const held = identityId === void 0 ? [] : (await client.identities.held(current.id)).data;
+  const grant = identityId === void 0 || held.some((one) => one.id === identityId) ? null : identityId;
+  const drifted = Object.keys(patch).length > 0 || missing !== null || grant !== null;
+  if (!drifted) return { name: decl.name, action: "unchanged", id: current.id };
+  if (!dryRun) {
+    if (Object.keys(patch).length > 0) await client.agents.update(current.id, patch);
+    if (grant !== null) await client.identities.attach(current.id, grant);
+  }
+  return { name: decl.name, action: "updated", id: current.id };
+}
+function drift(decl, current, tools, team, system, metadata) {
+  const patch = {};
+  if (changed(decl.model, current.model)) patch.model = decl.model;
+  if (changed(decl.budget, current.budget)) patch.budget = decl.budget;
+  if (changed(decl.description, current.description)) patch.description = decl.description;
+  if (changed(system, current.system)) patch.system = system;
+  if (changed(decl.skills, current.skills)) patch.skills = decl.skills;
+  if (changed(decl.mcp_servers, current.mcp_servers)) patch.mcp_servers = decl.mcp_servers;
+  if (changed(tools, current.tools)) patch.tools = tools;
+  if (changed(decl.window, current.window)) patch.window = decl.window;
+  if (team !== void 0 && changed(normaliseMultiagent(team), normaliseMultiagent(current.multiagent))) patch.multiagent = team;
+  if (changed(decl.handoffs, handoffsOf(current))) patch.handoffs = decl.handoffs;
+  if (changed(decl.output_schema, current.output_schema)) patch.output_schema = decl.output_schema;
+  if (changed(decl.structured_output_required, current.structured_output_required)) patch.structured_output_required = decl.structured_output_required;
+  if (changed(metadata, current.metadata)) patch.metadata = metadata;
+  return patch;
+}
+async function openIntake(client, agent, decl, dryRun) {
+  if (dryRun || agent.id === void 0) return { name: agent.name, action: "created" };
+  const started = await client.sessions.create({
+    agent_id: agent.id,
+    message: decl.message,
+    ...decl.budget_micro_usd !== void 0 ? { budget_micro_usd: decl.budget_micro_usd } : {}
+  });
+  return { name: agent.name, action: "created", id: started.id };
+}
+function brief(input) {
+  const first = input.trim().split(/(?<=[.!?])\s|\n/)[0]?.trim() ?? "";
+  const text = first.replace(/[.\s]+$/, "");
+  return text.length > 72 ? `${text.slice(0, 71).trimEnd()}\u2026` : text;
+}
+async function upsertSchedule(client, agent, decl, current, identityIds, dryRun) {
+  const name = `${agent.name} @ ${decl.cron}`;
+  if (agent.action === "refused") throw new Error(`agent "${agent.name}" was not provisioned in this run`);
+  const identity = decl.identity === void 0 ? void 0 : identityIds.get(decl.identity);
+  const unresolved = decl.identity !== void 0 && identity === void 0;
+  if (unresolved && !dryRun) throw new Error(`identity needs "${decl.identity}", which was not provisioned in this run`);
+  if (!current) {
+    if (dryRun || agent.id === void 0) return { name, action: "created" };
+    const created = await client.deployments.create({
+      agent_id: agent.id,
+      cron: decl.cron,
+      input_template: decl.input,
+      budget_micro_usd: decl.budget_micro_usd,
+      ...decl.timezone !== void 0 ? { timezone: decl.timezone } : {},
+      ...identity !== void 0 ? { identity } : {},
+      ...decl.enabled !== void 0 ? { enabled: decl.enabled } : {}
+    });
+    return { name, action: "created", id: created.id };
+  }
+  const patch = {};
+  if (changed(decl.timezone, current.timezone)) patch.timezone = decl.timezone;
+  if (changed(decl.input, current.input_template)) patch.input_template = decl.input;
+  if (changed(decl.budget_micro_usd, current.budget_micro_usd)) patch.budget_micro_usd = decl.budget_micro_usd;
+  if (changed(identity, current.identity)) patch.identity = identity;
+  if (changed(decl.enabled, current.enabled)) patch.enabled = decl.enabled;
+  if (Object.keys(patch).length === 0 && !unresolved) return { name, action: "unchanged", id: current.id };
+  if (!dryRun) await client.deployments.update(current.id, patch);
+  return { name, action: "updated", id: current.id };
+}
+async function reconcileSchedules(client, agent, declared, live, identityIds, dryRun, into) {
+  const rows = live.filter((row) => row.agent_id === agent.id);
+  into.push(
+    ...await eachInFlight(declared, async (decl) => ({
+      ...await line(
+        `${agent.name} @ ${decl.cron}`,
+        () => upsertSchedule(client, agent, decl, rows.find((row) => row.cron === decl.cron), identityIds, dryRun)
+      ),
+      // `<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)
+    }))
+  );
+  if (agent.action === "refused") return;
+  for (const row of rows.filter((row2) => !declared.some((decl) => decl.cron === row2.cron))) {
+    const name = `${agent.name} @ ${row.cron}`;
+    await attempt(into, name, () => tombstone(name, row, (id) => client.deployments.delete(id), dryRun));
+  }
+}
+
 // src/reconcile-cards.ts
 var LIVE = /* @__PURE__ */ new Set(["pending_payment", "issuing", "active"]);
 var nameOf = (identity, decl) => `${identity} / card ${decl.label}`;
@@ -4084,17 +4743,22 @@ async function upsertSkill(client, decl, opts) {
   const pushed = await client.skills.push({ slug: decl.slug, content, sha256 });
   return { name: decl.slug, action, id: pushed.id };
 }
-async function upsertIdentity(client, decl, dryRun, identityIds) {
+async function upsertIdentity(client, decl, dryRun, identityIds, owner) {
   const current = await absent(client.identities.get(decl.name));
   if (!current) {
     if (dryRun) return { name: decl.name, action: "created" };
     const created = await client.identities.create({
       name: decl.name,
-      ...decl.description !== void 0 ? { description: decl.description } : {}
+      ...decl.description !== void 0 ? { description: decl.description } : {},
+      ...owner !== void 0 ? { metadata: { project: owner } } : {}
     });
     identityIds.set(decl.name, created.id);
     return { name: decl.name, action: "created", id: created.id };
   }
+  const held = typeof current.metadata["project"] === "string" ? current.metadata["project"] : null;
+  if (owner !== void 0 && held !== owner) {
+    return { name: decl.name, action: "refused", id: current.id, reason: ownershipRefusal(decl.name, owner, held, "identity") };
+  }
   identityIds.set(decl.name, current.id);
   const drifted = decl.description !== void 0 && decl.description !== current.description;
   if (drifted && !dryRun) await client.identities.update(current.id, { description: decl.description ?? null });
@@ -4157,12 +4821,14 @@ async function up(config, client, opts = {}) {
   const taken = selectCrew(config, opts.select);
   const report2 = { dry_run: dryRun, ...applied(config), skills: [], identities: [], vaults: [], apps: [], agents: [], schedules: [], intake: [], tasks: [], skipped: [], deselected: taken.deselected };
   const owner = { project: config.name, adopt: opts.adopt ?? false, skipped: report2.skipped };
+  const project = opts.project ?? config.name;
+  const isolated = opts.isolated === true ? project : void 0;
   const hosted = opts.trees !== void 0;
   for (const decl of config.skills) {
     await attempt(report2.skills, decl.slug, () => upsertSkill(client, decl, { dryRun, dir, hosted, skills: opts.skills ?? {} }));
   }
   for (const decl of config.identities) {
-    await attempt(report2.identities, decl.name, () => upsertIdentity(client, decl, dryRun, ids.identities));
+    await attempt(report2.identities, decl.name, () => upsertIdentity(client, decl, dryRun, ids.identities, isolated));
     const identityId = ids.identities.get(decl.name);
     report2.identities.push(...await reportLegal(client, decl.legal ?? [], identityId, report2.skipped));
     for (const wallet of decl.wallet === void 0 ? [] : Array.isArray(decl.wallet) ? decl.wallet : [decl.wallet]) {
@@ -4191,7 +4857,7 @@ async function up(config, client, opts = {}) {
     ...opts.platform,
     known: {
       ...opts.platform.known,
-      [PLATFORM_ENV.project]: opts.project ?? config.name,
+      [PLATFORM_ENV.project]: project,
       ...identityEnv(config, ids.identities)
     }
   };
@@ -4224,9 +4890,10 @@ async function up(config, client, opts = {}) {
   );
   const existing = taken.agents.length > 0 || config.removed.agents.length > 0 || config.kept.agents.length > 0 || config.tasks.length > 0 ? await listAll(client.config, "/v1/agents", AgentSchema, report2.skipped) : [];
   const deployments = taken.agents.some((decl) => decl.schedules !== void 0) ? await listAll(client.config, "/v1/deployments", DeploymentSchema, report2.skipped) : [];
-  const scoped = config.apps.length > 0 ? [...ids.apps.values()] : void 0;
+  const scoped2 = config.apps.length > 0 ? [...ids.apps.values()] : void 0;
   const crew = await eachInFlight(taken.agents, async (decl) => {
-    const agent = await line(decl.name, () => upsertAgent(client, decl, existing, ids, dryRun, scoped, { project: opts.project ?? config.name, ...applied(config) }));
+    const of = { project, ...applied(config), adopt: opts.adopt ?? false, ...isolated === void 0 ? {} : { group: project } };
+    const agent = await line(decl.name, () => upsertAgent(client, decl, existing, ids, dryRun, scoped2, of));
     const schedules = [];
     if (decl.schedules !== void 0) {
       await reconcileSchedules(client, agent, decl.schedules, deployments, ids.identities, dryRun, schedules);
@@ -4263,6 +4930,56 @@ async function up(config, client, opts = {}) {
   );
   return report2;
 }
+
+// src/scoped.ts
+function scoped(config, prefix, project) {
+  const removed = { ...config.removed, skills: [] };
+  if (prefix === "") return { ...config, name: project, removed };
+  const as = (name) => prefix + name;
+  const apps = new Set(config.apps.map((app) => app.name));
+  const tool = (key) => {
+    const app = key.split(".")[0] ?? "";
+    return key.includes(".") && apps.has(app) ? as(key) : key;
+  };
+  const team = teamLine(config, as);
+  const agent = (decl) => ({
+    ...decl,
+    name: as(decl.name),
+    system: decl.system === void 0 ? team : `${decl.system}
+
+${team}`,
+    ...decl.tools === void 0 ? {} : { tools: { ...decl.tools, configs: Object.fromEntries(Object.entries(decl.tools.configs).map(([key, one]) => [tool(key), one])) } },
+    ...decl.allowed_apps === void 0 ? {} : { allowed_apps: decl.allowed_apps.map(as) },
+    ...decl.identity === void 0 ? {} : { identity: as(decl.identity) },
+    ...Array.isArray(decl.handoffs) ? { handoffs: decl.handoffs.map(as) } : {},
+    ...hasRoster(decl.multiagent) ? { multiagent: { ...decl.multiagent, agents: decl.multiagent.agents.map((one) => one.type === "agent" ? { ...one, name: as(one.name) } : one) } } : {},
+    ...decl.schedules === void 0 ? {} : { schedules: decl.schedules.map((one) => one.identity === void 0 ? one : { ...one, identity: as(one.identity) }) }
+  });
+  return {
+    ...config,
+    name: project,
+    identities: config.identities.map((one) => ({ ...one, name: as(one.name) })),
+    vaults: config.vaults.map((one) => ({ ...one, name: as(one.name), ...one.identity === void 0 ? {} : { identity: as(one.identity) } })),
+    apps: config.apps.map((one) => ({ ...one, name: as(one.name) })),
+    agents: config.agents.map(agent),
+    tasks: config.tasks.map((one) => one.assignee === void 0 ? one : { ...one, assignee: as(one.assignee) }),
+    removed: {
+      ...removed,
+      apps: config.removed.apps.map(as),
+      agents: config.removed.agents.map(as),
+      identities: config.removed.identities.map(as),
+      vaults: config.removed.vaults.map(as)
+    },
+    kept: { agents: config.kept.agents.map(as) }
+  };
+}
+function teamLine(config, as) {
+  const names = [
+    ...config.agents.map((one) => `${one.name} is ${as(one.name)}`),
+    ...config.apps.map((one) => `the app ${one.name} is ${as(one.name)} (its tools are ${as(one.name)}.*)`)
+  ];
+  return `Your team's names here: ${names.join("; ")}.`;
+}
 export {
   BLUEPRINTS,
   BlueprintRefusal,
@@ -4279,6 +4996,7 @@ export {
   loadConfig,
   migrationFiles,
   parseProject,
+  scoped,
   selectCrew,
   up
 };