@usenaive-sdk/blueprints 0.5.0 → 0.7.0

package/dist/index.js

@@ -301,7 +301,7 @@ var HARNESS_IDS = ["pi", "claude_code", "vetta", "hermes"];
 var HarnessIdSchema = z2.enum(HARNESS_IDS);
 
 // ../core/src/schema/agent.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../core/src/schema/browser.ts
 import { z as z4 } from "zod";
@@ -553,16 +553,70 @@ var BrowserCredentialSchema = z4.object({
 });
 var LiveViewSchema = z4.object({ url: z4.string().url(), expires_at: Timestamp });
 
+// ../core/src/schema/model-selection.ts
+import { z as z5 } from "zod";
+var MODEL_SELECTION_MIN_OPTIONS = 2;
+var MODEL_SELECTION_MAX_OPTIONS = 16;
+var MODEL_SELECTION_MAX_MESSAGES = 32;
+var MODEL_SELECTION_MAX_CONTENT_CHARS = 32e3;
+var ModelSelectionMessageSchema = z5.object({
+  role: z5.enum(["user", "assistant"]),
+  content: z5.string().min(1)
+});
+var OptionsSchema = z5.record(z5.string().min(1), z5.string().trim().min(1).max(500)).refine((options) => Object.keys(options).length >= MODEL_SELECTION_MIN_OPTIONS, {
+  message: `at least ${MODEL_SELECTION_MIN_OPTIONS} options are required`
+}).refine((options) => Object.keys(options).length <= MODEL_SELECTION_MAX_OPTIONS, {
+  message: `at most ${MODEL_SELECTION_MAX_OPTIONS} options are allowed`
+});
+var ModelSelectionPolicySchema = z5.object({
+  options: OptionsSchema,
+  min_confidence: z5.number().gt(0).max(1).optional()
+});
+var ModelSelectionRequestSchema = z5.object({
+  options: OptionsSchema,
+  messages: z5.array(ModelSelectionMessageSchema).min(1).max(MODEL_SELECTION_MAX_MESSAGES),
+  default: z5.string().min(1).optional(),
+  min_confidence: z5.number().gt(0).max(1).optional()
+}).superRefine((body, ctx) => {
+  const total = body.messages.reduce((sum, message3) => sum + message3.content.length, 0);
+  if (total > MODEL_SELECTION_MAX_CONTENT_CHARS) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["messages"],
+      message: `total message content exceeds ${MODEL_SELECTION_MAX_CONTENT_CHARS} characters`
+    });
+  }
+  if (body.default !== void 0 && !Object.hasOwn(body.options, body.default)) {
+    ctx.addIssue({ code: "custom", path: ["default"], message: "default must be one of the options" });
+  }
+  if (body.min_confidence !== void 0 && body.default === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["min_confidence"],
+      message: "min_confidence requires a default to fall back to"
+    });
+  }
+});
+var ModelSelectionSchema = z5.object({
+  object: z5.literal("model_selection"),
+  model: z5.string().min(1),
+  confidence: z5.number().min(0).max(1).nullable(),
+  probabilities: z5.record(z5.string(), z5.number()).nullable(),
+  defaulted: z5.boolean(),
+  spent_micro_usd: z5.number().int().nonnegative(),
+  usage: z5.object({ input_tokens: z5.number().int().nonnegative() })
+});
+
 // ../core/src/schema/agent.ts
-var ToolPermissionSchema = z5.enum(["allow", "ask", "deny"]);
-var ToolConfigSchema = z5.object({
-  enabled: z5.boolean(),
+var ToolPermissionSchema = z6.enum(["allow", "ask", "deny"]);
+var ToolConfigSchema = z6.object({
+  enabled: z6.boolean(),
   permission: ToolPermissionSchema,
-  config: z5.record(z5.string(), z5.unknown()).optional()
+  config: z6.record(z6.string(), z6.unknown()).optional()
 });
-var ToolsetSchema = z5.object({
-  default_config: z5.object({ permission: ToolPermissionSchema }),
-  configs: z5.record(z5.string(), ToolConfigSchema)
+var ToolsetSchema = z6.object({
+  default_config: z6.object({ permission: ToolPermissionSchema }),
+  configs: z6.record(z6.string(), ToolConfigSchema)
 }).superRefine((tools, ctx) => {
   const config = tools.configs["browser"]?.config;
   if (config === void 0) return;
@@ -570,83 +624,85 @@ var ToolsetSchema = z5.object({
     ctx.addIssue({ code: "custom", message: issue.message, path: ["configs", "browser", "config", ...issue.path] });
   }
 });
-var BudgetSchema = z5.object({
+var BudgetSchema = z6.object({
   cap_micro_usd: MicroUsdField.nonnegative(),
   max_task_micro_usd: MicroUsdField.nonnegative(),
-  period: z5.enum(["day", "week", "month"])
+  period: z6.enum(["day", "week", "month"])
 });
-var SkillRefSchema = z5.string().regex(/^(naive\/)?[a-z0-9][a-z0-9-]*(@\d+)?$/, {
+var SkillRefSchema = z6.string().regex(/^(naive\/)?[a-z0-9][a-z0-9-]*(@\d+)?$/, {
   error: "expected `slug`, `slug@N`, `naive/slug` or `naive/slug@N`"
 });
-var McpServerSchema = z5.object({
-  name: z5.string(),
-  url: z5.url(),
-  headers: z5.record(z5.string(), z5.string()).optional()
+var McpServerSchema = z6.object({
+  name: z6.string(),
+  url: z6.url(),
+  headers: z6.record(z6.string(), z6.string()).optional()
 });
-var RosterEntrySchema = z5.union([
+var RosterEntrySchema = z6.union([
   idOf("agt").transform((id) => ({ type: "agent", id })),
-  z5.object({
-    type: z5.literal("agent"),
+  z6.object({
+    type: z6.literal("agent"),
     id: idOf("agt"),
-    version: z5.number().int().positive().optional()
+    version: z6.number().int().positive().optional()
   }),
-  z5.object({ type: z5.literal("self") }),
-  z5.object({ type: z5.literal("advisor"), model: z5.string().min(1) })
+  z6.object({ type: z6.literal("self") }),
+  z6.object({ type: z6.literal("advisor"), model: z6.string().min(1) })
 ]);
 var SINGLETON_ENTRIES = ["self", "advisor"];
-var MultiagentSchema = z5.object({
-  type: z5.literal("coordinator"),
-  agents: z5.array(RosterEntrySchema).min(1).max(20).refine(
+var MultiagentSchema = z6.object({
+  type: z6.literal("coordinator"),
+  agents: z6.array(RosterEntrySchema).min(1).max(20).refine(
     (roster) => SINGLETON_ENTRIES.every((t) => roster.filter((e) => e.type === t).length <= 1),
     { error: "a roster carries at most one `self` and at most one `advisor` entry" }
   ),
-  board: z5.boolean().optional()
+  board: z6.boolean().optional()
 });
-var MultiagentField = z5.union([z5.boolean(), MultiagentSchema, z5.null()]);
+var MultiagentField = z6.union([z6.boolean(), MultiagentSchema, z6.null()]);
 function normaliseMultiagent(value) {
   if (value === true) return { type: "coordinator", agents: [], board: false };
   if (value === false || value === null) return null;
   return value;
 }
-var HandoffsField = z5.union([z5.boolean(), z5.literal("team"), z5.array(z5.string().min(1)).max(50)]);
+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 agentConfigShape = {
-  model: z5.string(),
+  model: z6.string(),
   window: WindowSchema,
-  system: z5.string(),
+  system: z6.string(),
   tools: ToolsetSchema,
-  mcp_servers: z5.array(McpServerSchema),
-  skills: z5.array(SkillRefSchema),
+  mcp_servers: z6.array(McpServerSchema),
+  skills: z6.array(SkillRefSchema),
   multiagent: MultiagentField,
   /** Optional on the type so a version minted before §28.15 still parses; read it through `handoffsOf`. */
   handoffs: HandoffsField.optional(),
+  /** §46.6: when set, every turn picks one of its options and `model` is the default. Absent before it existed. */
+  model_selection: ModelSelectionPolicySchema.nullable().optional(),
   budget: BudgetSchema,
   output_schema: JsonSchemaDocument.nullable(),
-  structured_output_required: z5.boolean(),
-  description: z5.string().nullable(),
+  structured_output_required: z6.boolean(),
+  description: z6.string().nullable(),
   metadata: Metadata
 };
-var AgentVersionSchema = z5.object({
-  version: z5.number().int().positive(),
+var AgentVersionSchema = z6.object({
+  version: z6.number().int().positive(),
   created_at: Timestamp,
   created_by: PrincipalSchema,
   ...agentConfigShape
 });
-var AgentSchema = z5.object({
+var AgentSchema = z6.object({
   id: idOf("agt"),
-  object: z5.literal("agent"),
-  name: z5.string(),
+  object: z6.literal("agent"),
+  name: z6.string(),
   /** The agent loop this agent runs (§19). Chosen at create; the catalog lives in `harness.ts`. */
   harness: HarnessIdSchema,
-  current_version: z5.number().int().positive(),
+  current_version: z6.number().int().positive(),
   created_at: Timestamp,
   ...agentConfigShape
 });
 
 // ../core/src/schema/session.ts
-import { z as z6 } from "zod";
-var SessionStatusSchema = z6.enum([
+import { z as z7 } from "zod";
+var SessionStatusSchema = z7.enum([
   "queued",
   "running",
   "idle",
@@ -654,7 +710,7 @@ var SessionStatusSchema = z6.enum([
   "failed",
   "cancelled"
 ]);
-var StopReasonSchema = z6.enum([
+var StopReasonSchema = z7.enum([
   "end_turn",
   "awaiting_input",
   "awaiting_approval",
@@ -680,61 +736,86 @@ var StopReasonSchema = z6.enum([
    */
   "awaiting_answer"
 ]);
-var ThreadRoleSchema = z6.enum(["coordinator", "member"]);
-var MessageSchema = z6.object({
-  role: z6.enum(["system", "user", "assistant", "tool"]),
-  content: z6.string(),
-  tool_call_id: z6.string().optional()
-});
-var ToolResultSchema = z6.object({
-  output: z6.unknown(),
-  is_error: z6.boolean().optional(),
-  content: z6.string().optional()
+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 ToolImageSchema = z7.object({
+  data: z7.string().min(1).max(5e6).describe("The image's bytes, base64."),
+  media_type: z7.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 QuestionFieldBase = {
-  key: z6.string().min(1).max(64),
-  label: z6.string().min(1).max(200),
-  help: z6.string().max(500).optional()
+  key: z7.string().min(1).max(64),
+  label: z7.string().min(1).max(200),
+  help: z7.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.
+   *
+   * It exists for the question whose answer genuinely improves the work and does not gate it: a
+   * template's setup form asking for a reference to imitate, say. Before the flag the only way to
+   * ask such a thing was to make it mandatory — which forces an answer out of someone who has none,
+   * and an invented answer is worse than an absent one, because the crew cannot tell them apart.
+   *
+   * Nothing downstream needs an "if absent" branch: `projectContextFor` already lists only the
+   * questions that were answered, so an unanswered optional key is simply not in the context.
+   *
+   * ABSENT rather than `false`, which is why it is `.optional()` and not `.default(false)` like the
+   * `multiple` and `other` beside it. Those two sit on the `choice` branch, where a renderer has to
+   * branch on them and a definite value earns its place; this sits on the base, next to `help`,
+   * which is absent-by-default for the same reason. A default here would make `optional: boolean`
+   * 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()
 };
-var QuestionFieldSchema = z6.discriminatedUnion("type", [
-  z6.object({
+var QuestionFieldSchema = z7.discriminatedUnion("type", [
+  z7.object({
     ...QuestionFieldBase,
-    type: z6.literal("text"),
-    placeholder: z6.string().max(200).optional()
+    type: z7.literal("text"),
+    placeholder: z7.string().max(200).optional()
   }),
-  z6.object({
+  z7.object({
     ...QuestionFieldBase,
-    type: z6.literal("choice"),
+    type: z7.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: z6.array(z6.string().min(1).max(200)).min(2).max(12),
-    multiple: z6.boolean().default(false),
+    options: z7.array(z7.string().min(1).max(200)).min(2).max(12),
+    multiple: z7.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: z6.boolean().default(true)
+    other: z7.boolean().default(true)
   })
 ]);
-var QuestionSchema = z6.object({
-  prompt: z6.string().min(1).max(1e3),
-  fields: z6.array(QuestionFieldSchema).min(1).max(3)
+var QuestionSchema = z7.object({
+  prompt: z7.string().min(1).max(1e3),
+  fields: z7.array(QuestionFieldSchema).min(1).max(3)
 });
-var AnswersSchema = z6.record(
-  z6.string().min(1).max(64),
-  z6.union([z6.string().max(2e3), z6.array(z6.string().max(2e3)).min(1).max(12)])
+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 = z6.object({
-  kind: z6.enum(["tool", "question"]).default("tool"),
-  tool_call_id: z6.string(),
-  name: z6.string(),
-  args: z6.record(z6.string(), z6.unknown()),
+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()),
   /**
    * 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
@@ -743,11 +824,11 @@ var PendingActionSchema = z6.object({
    */
   question: QuestionSchema.optional()
 });
-var SessionSchema = z6.object({
+var SessionSchema = z7.object({
   id: idOf("ses"),
-  object: z6.literal("session"),
+  object: z7.literal("session"),
   agent_id: idOf("agt"),
-  agent_version: z6.number().int().positive(),
+  agent_version: z7.number().int().positive(),
   deployment_id: idOf("dep").nullable(),
   /**
    * The persona this session acts as (`canonical-spec §22`). Chosen per task from the personas the
@@ -776,50 +857,109 @@ var SessionSchema = z6.object({
   budget_micro_usd: MicroUsdField.nonnegative(),
   consumed_micro_usd: MicroUsdField.nonnegative(),
   token_usage: TokenUsageSchema,
-  pending_actions: z6.array(PendingActionSchema),
+  pending_actions: z7.array(PendingActionSchema),
   output_schema: JsonSchemaDocument.nullable(),
-  structured_output: z6.record(z6.string(), z6.unknown()).nullable(),
-  last_seq: z6.number().int().nonnegative(),
+  structured_output: z7.record(z7.string(), z7.unknown()).nullable(),
+  last_seq: z7.number().int().nonnegative(),
   metadata: Metadata,
   started_at: Timestamp.nullable(),
   ended_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var SendMessageSchema = z6.object({
-  message: z6.string(),
-  interrupt: z6.boolean().optional(),
-  idempotency_key: z6.string().optional()
-});
-var SendAcceptedSchema = z6.object({
-  session_id: z6.string(),
+var SendMessageSchema = z7.object({
+  message: z7.string(),
+  interrupt: z7.boolean().optional(),
+  queue: z7.boolean().optional(),
+  idempotency_key: z7.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(),
   status: SessionStatusSchema,
-  accepted_seq: z6.number().int().nonnegative()
+  accepted_seq: z7.number().int().nonnegative()
 });
-var ToolConfirmationSchema = z6.object({
-  tool_call_id: z6.string(),
-  decision: z6.enum(["allow", "deny"]),
-  reason: z6.string().optional(),
-  scope: z6.enum(["call", "session"]).default("call")
+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 SessionAnswerSchema = z6.object({
-  tool_call_id: z6.string(),
-  answers: z6.record(z6.string(), z6.union([z6.string(), z6.array(z6.string())]))
+var SessionAnswerSchema = z7.object({
+  tool_call_id: z7.string(),
+  answers: z7.record(z7.string(), z7.union([z7.string(), z7.array(z7.string())]))
 });
 
 // ../core/src/schema/event.ts
-import { z as z7 } from "zod";
-var EventTypeSchema = z7.enum([
+import { z as z8 } from "zod";
+var EventTypeSchema = z8.enum([
   "message.delta",
   "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",
+  /** A person's fan-out, on the sender's log without waking it (§8, §28.16): `{ client_message_id, content, handoffs, refusals }`. */
+  "handoff.sent",
   "tool.started",
   "tool.completed",
   "tool.confirm",
   "session.running",
   "session.usage",
   "session.idle",
+  /** A failed attempt the loop will retry (§8): `{ attempt, in_ms, code }`. */
+  "session.retrying",
+  /**
+   * 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"`.
+   *
+   * `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
+   * establishing with raw Connect RPC that the vendor was refusing every `ResumeSession` on the
+   * account — a question the adapter could have answered, since its give-up names the vendor state
+   * it last saw and how long it waited (`compute-tenki index.ts`). It is diagnostic prose, not a
+   * contract: never parse it, and it may be absent.
+   */
+  "session.degraded",
+  /**
+   * The session let go of a sandbox that would not resume and will run the next turn on a fresh
+   * one: `{ from, reason, failures, replacements }`.
+   *
+   * *** THE ONE TURN WHERE A FILESYSTEM ACTUALLY GOES MISSING USED TO BE THE SILENT ONE. ***
+   * `session.degraded` marks the turns whose resume FAILED, and those turns lose nothing — the box
+   * is still there and the next turn may still get it back. The turn that swaps the box is the
+   * damaging one, and it has no failure to report: it provisions a replacement and runs normally.
+   * Staging watched a session answer `cat: … No such file or directory` with nothing in its event
+   * log to tell that apart from the file never having been written, and support could not tell
+   * either. `from` is the box that was let go of, so a customer can still reach it through
+   * `GET /v1/computers/:id` while it lives.
+   *
+   * `reason` is open like `session.degraded`'s, and it carries the one distinction an operator
+   * cannot make any other way: `"resume_refused"` is the FIRST swap, where everything knowable here
+   * says the fault is that box's, and `"vendor_resume_unavailable"` is a swap that follows one — a
+   * fault that already outlived a fresh machine, so it is the account and not the box.
+   * `replacements` counts them. There is no third swap: past `box.ts MAX_BOX_REPLACEMENTS` the
+   * session keeps the box it holds and reports `session.degraded` under that same
+   * `vendor_resume_unavailable` reason, rather than abandoning one more live micro-VM every cycle
+   * for a fault a fresh one demonstrably does not fix.
+   */
+  "session.computer_replaced",
   "budget.exceeded",
   "span.model_request.start",
   "span.model_request.end",
+  // Pre-model spans (§15): what the gap before the first model request was spent on.
+  "span.transcript_load.start",
+  "span.transcript_load.end",
+  "span.harness_load.start",
+  "span.harness_load.end",
+  "span.harness_build.start",
+  "span.harness_build.end",
+  "span.box_resume.start",
+  "span.box_resume.end",
   /**
    * A delegated thread's lifecycle, on the **coordinator's** stream (§28). The child's own
    * `ses_…` rides inside `data.thread_id` — the event schema gains no field and `vetta.event` gains
@@ -854,55 +994,63 @@ var EventTypeSchema = z7.enum([
   "card.refunded",
   "card.credentials_revealed"
 ]);
-var EventSchema = z7.object({
+var EventSchema = z8.object({
   id: idOf("evt"),
-  seq: z7.number().int().positive(),
+  seq: z8.number().int().positive(),
   type: EventTypeSchema,
   session_id: idOf("ses"),
-  data: z7.record(z7.string(), z7.unknown()),
+  data: z8.record(z8.string(), z8.unknown()),
   created_at: Timestamp
 });
-var ThreadEventDataSchema = z7.looseObject({ thread_id: idOf("ses") });
-var SessionUsageDataSchema = z7.object({
+var ThreadEventDataSchema = z8.looseObject({ thread_id: idOf("ses") });
+var SessionUsageDataSchema = z8.object({
   token_usage: TokenUsageSchema,
   consumed_micro_usd: MicroUsdField.nonnegative(),
-  active_seconds: z7.number().nonnegative(),
-  tool_calls: z7.number().int().nonnegative()
+  active_seconds: z8.number().nonnegative(),
+  tool_calls: z8.number().int().nonnegative()
 });
 
 // ../core/src/schema/board.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var BOARD_STATUSES = ["todo", "doing", "blocked", "done"];
-var BoardStatusSchema = z8.enum(BOARD_STATUSES);
-var BoardCountsSchema = z8.object({
-  todo: z8.number().int().nonnegative(),
-  doing: z8.number().int().nonnegative(),
-  blocked: z8.number().int().nonnegative(),
-  done: z8.number().int().nonnegative()
-});
-var BoardSchema = z8.object({
+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({
   id: idOf("brd"),
-  object: z8.literal("board"),
+  object: z9.literal("board"),
   agent_id: idOf("agt"),
   cards: BoardCountsSchema,
   created_at: Timestamp
 });
-var BoardCardSchema = z8.object({
+var BoardCardSchema = z9.object({
   id: idOf("crd"),
-  object: z8.literal("board_card"),
+  object: z9.literal("board_card"),
   board_id: idOf("brd"),
-  title: z8.string().min(1),
-  body: z8.string(),
+  title: z9.string().min(1),
+  /** The brief — what was asked. */
+  body: z9.string(),
+  /** What the holder wrote back; a `done` carries one. */
+  note: z9.string().nullable().default(null),
   status: BoardStatusSchema,
-  assignee: z8.string().nullable(),
+  assignee: z9.string().nullable(),
   /** The cards this one waits on. A `blocked` card with an empty list is stuck on the world. */
-  blocked_by: z8.array(idOf("crd")),
+  blocked_by: z9.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),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var BoardCommentSchema = z8.object({
+var BoardCommentSchema = z9.object({
   id: idOf("bcm"),
-  object: z8.literal("board_comment"),
+  object: z9.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
@@ -910,42 +1058,42 @@ var BoardCommentSchema = z8.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: z8.string(),
-  body: z8.string(),
+  author: z9.string(),
+  body: z9.string(),
   created_at: Timestamp
 });
 
 // ../core/src/schema/identity.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var IDENTITY_NAME_MAX = 128;
 var IDENTITY_DESCRIPTION_MAX = 1024;
-var IdentitySchema = z9.object({
+var IdentitySchema = z10.object({
   id: idOf("idn"),
-  object: z9.literal("identity"),
+  object: z10.literal("identity"),
   /** Human-facing persona name. Surfaced to the model so it acts in character. */
-  name: z9.string().min(1).max(IDENTITY_NAME_MAX),
+  name: z10.string().min(1).max(IDENTITY_NAME_MAX),
   /** What the persona is for. The model reads it to choose tone, scope and endpoint. */
-  description: z9.string().max(IDENTITY_DESCRIPTION_MAX).nullable(),
+  description: z10.string().max(IDENTITY_DESCRIPTION_MAX).nullable(),
   /** Inbox addresses (`localpart@domain`) this identity owns. */
-  emails: z9.array(z9.string()),
+  emails: z10.array(z10.string()),
   /** Provisioned numbers in E.164. */
-  phones: z9.array(z9.string()),
+  phones: z10.array(z10.string()),
   /** Verified web domains reachable through this identity's inboxes. */
-  domains: z9.array(z9.string()),
+  domains: z10.array(z10.string()),
   /** `conn_` ids of authorized third-party connections. */
-  connections: z9.array(z9.string()),
+  connections: z10.array(z10.string()),
   metadata: Metadata,
   created_at: Timestamp,
   updated_at: Timestamp
 });
 
 // ../core/src/schema/resource.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // ../core/src/schema/files-library.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var FILE_KINDS = ["image", "video", "audio", "document", "other"];
-var FileKindSchema = z10.enum(FILE_KINDS);
+var FileKindSchema = z11.enum(FILE_KINDS);
 var FILE_SOURCE_TYPES = [
   "upload",
   "url_import",
@@ -955,50 +1103,50 @@ var FILE_SOURCE_TYPES = [
   "screenshot",
   "speech_generation"
 ];
-var FileSourceTypeSchema = z10.enum(FILE_SOURCE_TYPES);
-var FileSourceSchema = z10.object({
+var FileSourceTypeSchema = z11.enum(FILE_SOURCE_TYPES);
+var FileSourceSchema = z11.object({
   type: FileSourceTypeSchema,
-  job_id: z10.union([idOf("med"), idOf("clj")]).nullable(),
-  url: z10.string().url().nullable()
+  job_id: z11.union([idOf("med"), idOf("clj")]).nullable(),
+  url: z11.string().url().nullable()
 });
-var FileTagsSchema = z10.array(z10.string().min(1).max(64)).max(32);
-var FileLibraryFieldsSchema = z10.object({
-  title: z10.string().max(256).nullable().default(null),
-  description: z10.string().max(4096).nullable().default(null),
+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),
   tags: FileTagsSchema.default([]),
   kind: FileKindSchema.default("other"),
   source: FileSourceSchema.nullable().default(null),
   thumbnail_file_id: idOf("fil").nullable().default(null),
-  width: z10.number().int().positive().nullable().default(null),
-  height: z10.number().int().positive().nullable().default(null),
-  duration_seconds: z10.number().nonnegative().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)
 });
-var UpdateFileSchema = z10.object({
-  title: z10.string().max(256).nullable().optional(),
-  description: z10.string().max(4096).nullable().optional(),
+var UpdateFileSchema = z11.object({
+  title: z11.string().max(256).nullable().optional(),
+  description: z11.string().max(4096).nullable().optional(),
   tags: FileTagsSchema.optional()
 });
-var ImportFileSchema = z10.object({
-  url: z10.string().url().startsWith("http"),
-  title: z10.string().max(256).optional(),
-  description: z10.string().max(4096).optional(),
+var ImportFileSchema = z11.object({
+  url: z11.string().url().startsWith("http"),
+  title: z11.string().max(256).optional(),
+  description: z11.string().max(4096).optional(),
   tags: FileTagsSchema.optional()
 });
 
 // ../core/src/schema/resource.ts
-var ComputerStatusSchema = z11.enum(["creating", "running", "paused", "failed", "destroyed"]);
-var VolumeSchema = z11.object({
+var ComputerStatusSchema = z12.enum(["creating", "running", "paused", "failed", "destroyed"]);
+var VolumeSchema = z12.object({
   id: idOf("vol"),
-  size_gb: z11.number().int().positive(),
-  mount_path: z11.string()
+  size_gb: z12.number().int().positive(),
+  mount_path: z12.string()
 });
-var ComputerSchema = z11.object({
+var ComputerSchema = z12.object({
   id: idOf("cmp"),
-  object: z11.literal("computer"),
-  name: z11.string(),
-  vcpu: z11.number().int().positive(),
-  memory_mb: z11.number().int().positive(),
-  disk_gb: z11.number().int().positive(),
+  object: z12.literal("computer"),
+  name: z12.string(),
+  vcpu: z12.number().int().positive(),
+  memory_mb: z12.number().int().positive(),
+  disk_gb: z12.number().int().positive(),
   status: ComputerStatusSchema,
   // core-gaps: U2-browser-api — the whole option object (§32.2); `{ allowed_domains }` still parses.
   browser: BrowserOptionsSchema.nullable(),
@@ -1006,125 +1154,125 @@ var ComputerSchema = z11.object({
   snapshot_id: idOf("snp").nullable(),
   created_at: Timestamp
 });
-var SnapshotSchema = z11.object({
+var SnapshotSchema = z12.object({
   snapshot_id: idOf("snp"),
   computer_id: idOf("cmp"),
   created_at: Timestamp
 });
-var ComputerProbeSchema = z11.object({
+var ComputerProbeSchema = z12.object({
   sampled_at: Timestamp,
-  uptime_seconds: z11.number().int().nonnegative(),
-  processes: z11.number().int().nonnegative(),
-  load_1m: z11.number().nonnegative(),
-  memory_used_mb: z11.number().int().nonnegative(),
-  memory_total_mb: z11.number().int().positive(),
-  disk_used_gb: z11.number().nonnegative(),
-  disk_total_gb: z11.number().positive()
-});
-var ComputerInspectSchema = z11.object({
-  object: z11.literal("computer_inspect"),
+  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"),
   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: z11.string().min(1).nullable(),
+  home: z12.string().min(1).nullable(),
   probe: ComputerProbeSchema.nullable()
 });
 var COMMAND_OUTPUT_CAP = 65536;
-var ComputerCommandSchema = z11.object({
+var ComputerCommandSchema = z12.object({
   id: idOf("cmd"),
-  object: z11.literal("computer_command"),
+  object: z12.literal("computer_command"),
   computer_id: idOf("cmp"),
-  command: z11.string(),
-  exit_code: z11.number().int().nullable(),
-  timed_out: z11.boolean(),
-  duration_ms: z11.number().int().nonnegative(),
-  stdout: z11.string().max(COMMAND_OUTPUT_CAP),
-  stderr: z11.string().max(COMMAND_OUTPUT_CAP),
-  truncated: z11.boolean(),
+  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(),
   actor: PrincipalSchema,
   created_at: Timestamp
 });
-var ExecStreamFrameSchema = z11.union([
-  z11.object({ stdout: z11.string() }),
-  z11.object({ stderr: z11.string() }),
-  z11.object({
-    exit: z11.object({
-      exit_code: z11.number().int().nullable(),
-      timed_out: z11.boolean(),
-      duration_ms: z11.number().int().nonnegative(),
+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(),
       command_id: idOf("cmd")
     })
   })
 ]);
-var FileEntryTypeSchema = z11.enum(["file", "directory", "symlink", "other"]);
-var FileEntrySchema = z11.object({
-  name: z11.string().min(1),
-  path: z11.string().min(1),
+var FileEntryTypeSchema = z12.enum(["file", "directory", "symlink", "other"]);
+var FileEntrySchema = z12.object({
+  name: z12.string().min(1),
+  path: z12.string().min(1),
   type: FileEntryTypeSchema,
-  size_bytes: z11.number().int().nonnegative(),
+  size_bytes: z12.number().int().nonnegative(),
   /** POSIX `st_mode`. */
-  mode: z11.number().int().nonnegative(),
+  mode: z12.number().int().nonnegative(),
   modified_at: Timestamp.nullable()
 });
-var ComputerUpdateSchema = z11.strictObject({ name: z11.string().min(1).max(200) });
-var SkillSchema = z11.object({
+var ComputerUpdateSchema = z12.strictObject({ name: z12.string().min(1).max(200) });
+var SkillSchema = z12.object({
   id: idOf("skl"),
-  object: z11.literal("skill"),
-  name: z11.string(),
-  description: z11.string().nullable(),
-  latest_version: z11.number().int().positive(),
+  object: z12.literal("skill"),
+  name: z12.string(),
+  description: z12.string().nullable(),
+  latest_version: z12.number().int().positive(),
   created_at: Timestamp
 });
-var ResolvedSkillRefSchema = z11.object({
+var ResolvedSkillRefSchema = z12.object({
   /** The reference exactly as the agent version wrote it: `slug` or `slug@N`. */
-  ref: z11.string().min(1),
-  slug: z11.string().min(1),
-  version: z11.number().int().positive(),
-  description: z11.string(),
-  storage_key: z11.string().min(1)
-});
-var SkillVersionSchema = z11.object({
-  version: z11.number().int().positive(),
-  sha256: z11.string().regex(/^[0-9a-f]{64}$/),
-  size_bytes: z11.number().int().nonnegative(),
+  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(),
   created_at: Timestamp
 });
-var SkillCatalogEntrySchema = z11.object({
-  object: z11.literal("skill_catalog_entry"),
-  slug: z11.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  version: z11.number().int().positive(),
-  name: z11.string().min(1),
-  description: z11.string(),
-  tags: z11.array(z11.string().min(1)),
-  content_hash: z11.string().regex(/^[0-9a-f]{64}$/),
+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}$/),
   published_at: Timestamp
 });
-var SkillCatalogVersionSchema = SkillCatalogEntrySchema.extend({ content: z11.string() });
-var FileSchema = z11.object({
+var SkillCatalogVersionSchema = SkillCatalogEntrySchema.extend({ content: z12.string() });
+var FileSchema = z12.object({
   id: idOf("fil"),
-  object: z11.literal("file"),
-  name: z11.string(),
-  content_type: z11.string(),
-  size_bytes: z11.number().int().nonnegative(),
-  scope: z11.enum(["session", "published"]),
+  object: z12.literal("file"),
+  name: z12.string(),
+  content_type: z12.string(),
+  size_bytes: z12.number().int().nonnegative(),
+  scope: z12.enum(["session", "published"]),
   session_id: idOf("ses").nullable(),
-  sha256: z11.string().regex(/^[0-9a-f]{64}$/),
+  sha256: z12.string().regex(/^[0-9a-f]{64}$/),
   created_at: Timestamp,
   // The asset-library fields (`canonical-spec §36.1`), all nullable or defaulted.
   ...FileLibraryFieldsSchema.shape
 });
-var ScheduleStatusSchema = z11.enum(["scheduled", "paused", "unscheduled"]);
-var DeploymentSchema = z11.object({
+var ScheduleStatusSchema = z12.enum(["scheduled", "paused", "unscheduled"]);
+var DeploymentSchema = z12.object({
   id: idOf("dep"),
-  object: z11.literal("deployment"),
+  object: z12.literal("deployment"),
   agent_id: idOf("agt"),
   /** A pin. `null` tracks the agent's `current_version` on every fire (§12). */
-  agent_version: z11.number().int().positive().nullable(),
-  cron: z11.string(),
+  agent_version: z12.number().int().positive().nullable(),
+  cron: z12.string(),
   /** IANA zone the `cron` is read in. "0 9 * * 1" means 09:00 *here*, across DST (ADR-0074). */
-  timezone: z11.string(),
-  input_template: z11.string(),
+  timezone: z12.string(),
+  input_template: z12.string(),
   budget_micro_usd: MicroUsdField.nonnegative(),
   window: WindowSchema,
   /**
@@ -1134,21 +1282,21 @@ var DeploymentSchema = z11.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: z11.url().startsWith("https://", { error: "a webhook URL must be https" }).nullable(),
+  on_idle: z12.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: z11.boolean(),
+  enabled: z12.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 = z11.object({
+var DeploymentRunSchema = z12.object({
   id: idOf("run"),
   session_id: idOf("ses"),
   status: SessionStatusSchema,
@@ -1156,62 +1304,62 @@ var DeploymentRunSchema = z11.object({
 });
 
 // ../core/src/schema/comms.ts
-import { z as z12 } from "zod";
-var DomainKindSchema = z12.enum(["system", "external", "purchased"]);
-var DomainStatusSchema = z12.enum(["pending_dns", "active", "failed"]);
-var DomainDnsStatusSchema = z12.enum(["pending_verification", "provisioned", "failed"]);
-var DomainInboundStatusSchema = z12.enum(["pending", "verified", "failed"]);
-var DomainAppConnectStatusSchema = z12.enum(["pending", "connected", "failed"]);
-var DnsRecordSchema = z12.object({
-  type: z12.enum(["TXT", "CNAME", "MX"]),
-  host: z12.string(),
-  value: z12.string(),
-  priority: z12.number().int().nullable(),
+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(),
   /** Vetta owns this record: `_dmarc`, DKIM, inbound MX. The agent may read it, never write it. */
-  managed: z12.boolean()
+  managed: z13.boolean()
 });
-var DomainSchema = z12.object({
+var DomainSchema = z13.object({
   id: idOf("dom"),
-  object: z12.literal("domain"),
+  object: z13.literal("domain"),
   /** A domain belongs to the **organization**, not to one identity: two identities share one. */
-  name: z12.string(),
+  name: z13.string(),
   kind: DomainKindSchema,
   status: DomainStatusSchema,
   dns_status: DomainDnsStatusSchema,
   inbound_status: DomainInboundStatusSchema,
   app_connect_status: DomainAppConnectStatusSchema,
-  records: z12.array(DnsRecordSchema),
+  records: z13.array(DnsRecordSchema),
   last_verified_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var EmailInboxSchema = z12.object({
+var EmailInboxSchema = z13.object({
   id: idOf("eml"),
-  object: z12.literal("email_inbox"),
+  object: z13.literal("email_inbox"),
   identity_id: idOf("idn"),
   domain_id: idOf("dom"),
-  address: z12.string(),
-  localpart: z12.string(),
+  address: z13.string(),
+  localpart: z13.string(),
   /** Inbound routing keys off this: mail to the address wakes exactly this agent. */
   owning_agent_id: idOf("agt"),
-  status: z12.enum(["active", "disabled"]),
+  status: z13.enum(["active", "disabled"]),
   created_at: Timestamp
 });
-var PhoneTierSchema = z12.enum(["sole_prop", "standard"]);
-var BrandStatusSchema = z12.enum(["none", "pending_verification", "verified", "rejected"]);
-var CampaignStatusSchema = z12.enum(["none", "pending", "approved", "rejected"]);
-var PhoneNumberSchema = z12.object({
+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({
   id: idOf("pho"),
-  object: z12.literal("phone_number"),
+  object: z13.literal("phone_number"),
   identity_id: idOf("idn"),
-  e164: z12.string(),
-  country: z12.string(),
-  capabilities: z12.object({
+  e164: z13.string(),
+  country: z13.string(),
+  capabilities: z13.object({
     /** Live the moment the number is bought — inbound never waits on carrier registration. */
-    sms_inbound: z12.boolean(),
+    sms_inbound: z13.boolean(),
     /** True **iff** `campaign_status === "approved"`. Nothing else may set it. */
-    sms_outbound: z12.boolean(),
+    sms_outbound: z13.boolean(),
     /** Voice is not a P2 capability; the field exists so its absence is explicit. */
-    voice: z12.literal(false)
+    voice: z13.literal(false)
   }),
   tier: PhoneTierSchema,
   brand_status: BrandStatusSchema,
@@ -1219,46 +1367,46 @@ var PhoneNumberSchema = z12.object({
   provisioned_at: Timestamp.nullable(),
   created_at: Timestamp
 });
-var InboundMessageSchema = z12.object({
+var InboundMessageSchema = z13.object({
   id: idOf("inb"),
-  object: z12.literal("inbound_message"),
-  channel: z12.enum(["email", "sms"]),
+  object: z13.literal("inbound_message"),
+  channel: z13.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: z12.string(),
-  from: z12.string(),
-  to: z12.string(),
-  subject: z12.string().nullable(),
-  text: z12.string(),
+  endpoint_id: z13.string(),
+  from: z13.string(),
+  to: z13.string(),
+  subject: z13.string().nullable(),
+  text: z13.string(),
   /** SPF/DKIM/DMARC for mail, carrier origin for SMS. Kept for the audit of why it was accepted. */
-  auth: z12.record(z12.string(), z12.string()),
+  auth: z13.record(z13.string(), z13.string()),
   /** The session this message woke. Null until the wake seam lands (see ADR-0120). */
   session_id: idOf("ses").nullable(),
   received_at: Timestamp
 });
 
 // ../core/src/schema/app.ts
-import { z as z13 } from "zod";
-var AppTypeSchema = z13.enum(["frontend_only", "fullstack"]);
-var AppStatusSchema = z13.enum(["provisioning", "active", "error"]);
-var AppMcpPathSchema = z13.string().regex(/^\/\S*$/, "must be an absolute path beginning with /").max(128);
-var AppSchema = z13.object({
+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({
   id: idOf("app"),
-  object: z13.literal("app"),
-  name: z13.string(),
-  description: z13.string().nullable(),
+  object: z14.literal("app"),
+  name: z14.string(),
+  description: z14.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: z13.string().nullable(),
+  project: z14.string().nullable(),
   status: AppStatusSchema,
   /** The address the app answers on — platform hostname until a custom domain connects. */
-  url: z13.string().nullable(),
+  url: z14.string().nullable(),
   /** White-label words when `status` is `error`; never the provider's. */
-  error: z13.string().nullable(),
+  error: z14.string().nullable(),
   /** Where the app serves MCP, or `null`. The bearer token for it is a server column. */
   mcp: AppMcpPathSchema.nullable(),
   /**
@@ -1266,49 +1414,49 @@ var AppSchema = z13.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: z13.boolean(),
+  dashboard: z14.boolean(),
   created_at: Timestamp
 });
-var AppDeploymentStatusSchema = z13.enum(["queued", "building", "ready", "error"]);
-var AppDeploymentSchema = z13.object({
+var AppDeploymentStatusSchema = z14.enum(["queued", "building", "ready", "error"]);
+var AppDeploymentSchema = z14.object({
   id: idOf("apd"),
-  object: z13.literal("app_deployment"),
+  object: z14.literal("app_deployment"),
   app_id: idOf("app"),
   status: AppDeploymentStatusSchema,
-  url: z13.string().nullable(),
-  error: z13.string().nullable(),
+  url: z14.string().nullable(),
+  error: z14.string().nullable(),
   /** The client's opaque digest of the files, echoed verbatim so it can skip an unchanged deploy. */
-  content_hash: z13.string().nullable(),
+  content_hash: z14.string().nullable(),
   created_at: Timestamp
 });
-var AppDeploymentFilesSchema = z13.object({
-  object: z13.literal("app_deployment_files"),
+var AppDeploymentFilesSchema = z14.object({
+  object: z14.literal("app_deployment_files"),
   deployment_id: idOf("apd"),
-  files: z13.record(z13.string().min(1), z13.string())
+  files: z14.record(z14.string().min(1), z14.string())
 });
-var AppSecretSchema = z13.object({
-  object: z13.literal("app_secret"),
-  name: z13.string(),
+var AppSecretSchema = z14.object({
+  object: z14.literal("app_secret"),
+  name: z14.string(),
   /** The client's opaque digest of the value, echoed verbatim so it can skip an unchanged write. */
-  value_hash: z13.string().nullable(),
+  value_hash: z14.string().nullable(),
   created_at: Timestamp
 });
-var AppEntrySchema = z13.object({
-  object: z13.literal("app_entry"),
-  url: z13.string(),
-  ticket: z13.string()
+var AppEntrySchema = z14.object({
+  object: z14.literal("app_entry"),
+  url: z14.string(),
+  ticket: z14.string()
 });
-var AppAccessSchema = z13.object({
-  object: z13.literal("app_access"),
-  url: z13.string().nullable(),
-  password: z13.string().nullable()
+var AppAccessSchema = z14.object({
+  object: z14.literal("app_access"),
+  url: z14.string().nullable(),
+  password: z14.string().nullable()
 });
-var AppDomainStatusSchema = z13.enum(["pending", "connected", "failed"]);
-var AppDomainSchema = z13.object({
-  object: z13.literal("app_domain"),
+var AppDomainStatusSchema = z14.enum(["pending", "connected", "failed"]);
+var AppDomainSchema = z14.object({
+  object: z14.literal("app_domain"),
   app_id: idOf("app"),
   domain_id: idOf("dom"),
-  domain: z13.string(),
+  domain: z14.string(),
   status: AppDomainStatusSchema,
   created_at: Timestamp
 });
@@ -1316,58 +1464,76 @@ var ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
 var APP_NAME = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
 
 // ../core/src/schema/install.ts
-import { z as z14 } from "zod";
-var BlueprintInstallSourceSchema = z14.enum(["studio", "cli"]);
-var BlueprintInstallStatusSchema = z14.enum(["pending", "applied", "failed"]);
-var ResourceActionSchema = z14.enum(["created", "updated", "unchanged", "deleted", "refused"]);
-var ResourceReportSchema = z14.object({
-  name: z14.string().min(1),
+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),
   action: ResourceActionSchema,
   /** The `agt_`/`app_`/`ses_`… the line resolved to. Absent on a refusal that never got an id. */
-  id: z14.string().optional(),
+  id: z15.string().optional(),
   /** An app's hostname once its build went live; `null` while it has none. Apps only. */
-  url: z14.string().nullable().optional(),
-  reason: z14.string().optional()
-});
-var BlueprintReportSchema = z14.object({
-  skills: z14.array(ResourceReportSchema),
-  identities: z14.array(ResourceReportSchema),
-  vaults: z14.array(ResourceReportSchema),
-  apps: z14.array(ResourceReportSchema),
-  agents: z14.array(ResourceReportSchema),
-  schedules: z14.array(ResourceReportSchema),
-  intake: z14.array(ResourceReportSchema),
-  skipped: z14.array(z14.string()),
-  deselected: z14.array(z14.string()).default([])
-});
-var BlueprintSelectionSchema = z14.object({
-  agents: z14.array(z14.string().min(1)),
-  apps: z14.array(z14.string().min(1))
-});
-var BlueprintInstallSchema = z14.object({
+  url: z15.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(),
+  /**
+   * 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
+   * about what it does, so a roadmap built from these lines could only ever have been a timetable.
+   * 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),
+  /** 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([])
+});
+var BlueprintSelectionSchema = z15.object({
+  agents: z15.array(z15.string().min(1)),
+  apps: z15.array(z15.string().min(1))
+});
+var BlueprintInstallSchema = z15.object({
   id: idOf("bpi"),
-  object: z14.literal("blueprint_install"),
+  object: z15.literal("blueprint_install"),
   /** The customer's own `defineProject({ name })` — the same word `app.project` stamps (§29.2). */
-  project: z14.string().min(1),
+  project: z15.string().min(1),
   /** The pair the declaration resolved to; `null` for a declaration that names no blueprint. */
-  blueprint: z14.string().nullable(),
-  template: z14.string().nullable(),
+  blueprint: z15.string().nullable(),
+  template: z15.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: z14.number().int().positive(),
+  revision: z15.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: z14.string().nullable(),
+  artifact_version: z15.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: z14.record(z14.string(), z14.unknown()),
+  answers: z15.record(z15.string(), z15.unknown()),
   /**
    * NO `declaration` ON THE WIRE, and that is the reconciliation of §29.6 with §31.1.
    *
@@ -1396,7 +1562,7 @@ var BlueprintInstallSchema = z14.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: z14.string().nullable(),
+  failure: z15.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.
@@ -1407,271 +1573,321 @@ var BlueprintInstallSchema = z14.object({
   applied_at: Timestamp,
   created_at: Timestamp
 });
-var ProjectContextAnswerSchema = z14.object({
-  key: z14.string().min(1),
-  label: z14.string(),
-  value: z14.union([z14.string(), z14.array(z14.string())])
-});
-var ProjectContextSchema = z14.object({
-  object: z14.literal("project_context"),
-  project: z14.string().min(1),
-  blueprint: z14.string().nullable(),
-  template: z14.string().nullable(),
-  artifact_version: z14.string().nullable(),
-  answers: z14.array(ProjectContextAnswerSchema),
-  apps: z14.array(z14.object({ name: z14.string().min(1), url: z14.string().nullable() })),
-  agents: z14.array(z14.object({ name: z14.string().min(1), role: z14.string().nullable() })),
+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() })),
   /** `context_updated_at` once the answers have been edited, `applied_at` until then. */
   updated_at: Timestamp
 });
 
 // ../core/src/schema/blueprint.ts
-import { z as z15 } from "zod";
-var BlueprintScheduleSchema = z15.object({
-  agent: z15.string().min(1),
-  cron: z15.string().min(1),
-  timezone: z15.string().nullable(),
+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),
+  timezone: z17.string().nullable(),
   /** The message each fire opens its session with — the sentence worth printing. */
-  input: z15.string().min(1),
+  input: z17.string().min(1),
   budget_micro_usd: MicroUsdField.nonnegative()
 });
 var BlueprintBudgetSchema = BlueprintScheduleSchema.pick({ agent: true, cron: true, budget_micro_usd: true });
-var BlueprintCrewSchema = z15.object({
-  name: z15.string().min(1),
-  description: z15.string().nullable(),
-  model: z15.string().min(1),
-  briefed: z15.boolean(),
-  intake: z15.string().nullable().optional(),
+var BlueprintCrewSchema = z17.object({
+  name: z17.string().min(1),
+  description: z17.string().nullable(),
+  model: z17.string().min(1),
+  briefed: z17.boolean(),
+  intake: z17.string().nullable().optional(),
   /** What the first session may spend: the intake's own cap, else the agent's (§31.4). Set iff `briefed`. */
   intake_micro_usd: MicroUsdField.nonnegative().optional(),
-  role: z15.string().min(1).optional(),
-  skills: z15.array(SkillRefSchema).optional(),
-  tools: z15.array(z15.string().min(1)).optional(),
-  required: z15.boolean().optional()
+  role: z17.string().min(1).optional(),
+  skills: z17.array(SkillRefSchema).optional(),
+  tools: z17.array(z17.string().min(1)).optional(),
+  required: z17.boolean().optional()
 });
-var BlueprintAppSchema = z15.object({
-  name: z15.string().min(1),
+var BlueprintAppSchema = z17.object({
+  name: z17.string().min(1),
   type: AppTypeSchema,
-  description: z15.string().nullable(),
-  mcp: z15.string().nullable().optional(),
-  tools: z15.array(z15.string().min(1)).optional(),
+  description: z17.string().nullable(),
+  mcp: z17.string().nullable().optional(),
+  tools: z17.array(z17.string().min(1)).optional(),
   /** Whether an install may deselect it (§31.2). Optional: the rollout argument above. */
-  required: z15.boolean().optional()
+  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()
 });
-var ContentHashSchema = z15.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
-var BlueprintTreeSchema = z15.object({
+var ContentHashSchema = z17.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
+var BlueprintTreeSchema = z17.object({
   /** `apps[].name` in the declaration — the same name §31.5 prints and the install ensures by. */
-  app: z15.string().min(1),
+  app: z17.string().min(1),
   content_hash: ContentHashSchema
 });
-var BlueprintArtifactSchema = z15.object({
+var BlueprintArtifactSchema = z17.object({
   id: idOf("bpa"),
-  object: z15.literal("blueprint_artifact"),
+  object: z17.literal("blueprint_artifact"),
   /** The machine — its repository, screens and `/api/*`. */
-  blueprint: z15.string().min(1),
+  blueprint: z17.string().min(1),
   /** Which of that blueprint's templates provides the crew. */
-  template: z15.string().min(1),
+  template: z17.string().min(1),
   /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
-  version: z15.string().min(1),
+  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`.
    */
-  trees: z15.array(BlueprintTreeSchema).min(1),
+  trees: z17.array(BlueprintTreeSchema).min(1),
   /**
    * The setup questions, asked by the studio **before** provisioning. `QuestionField` (§7.1) is
    * reused rather than restated: a setup question and a question a parked agent asks are the same
    * object at different times, so one component renders both.
    */
-  questions: z15.array(QuestionFieldSchema),
-  schedules: z15.array(BlueprintScheduleSchema),
+  questions: z17.array(QuestionFieldSchema),
+  schedules: z17.array(BlueprintScheduleSchema),
   /** Who the crew is, and what it deploys — §31.5. Derived from `declaration`, never stored twice. */
-  agents: z15.array(BlueprintCrewSchema),
-  apps: z15.array(BlueprintAppSchema),
+  agents: z17.array(BlueprintCrewSchema),
+  apps: z17.array(BlueprintAppSchema),
   /**
    * The agents a template creates per client the operator signs — printed, never provisioned by an
    * apply (§31.1). Absent on rows published before WS12 v2, hence optional.
    */
-  crew_per_client: z15.array(BlueprintCrewSchema).optional(),
+  crew_per_client: z17.array(BlueprintCrewSchema).optional(),
+  /**
+   * The personas the crew posts from, and which accounts to connect to each before the crew
+   * exists (§31.10). Derived from `declaration` like `agents`; optional for the §31.5 rollout reason.
+   */
+  identities: z17.array(BlueprintIdentitySchema).optional(),
   /**
    * The creator template a row was published from (§42.8), `null` on every first-party row.
    * `creator_name` is the public display name the landing page credits. The API sends all three
    * on every row; they are optional here only so an artifact typed before §42 still reads.
    */
   creator_template_id: idOf("ctp").nullish(),
-  creator_template_version: z15.number().int().positive().nullish(),
-  creator_name: z15.string().min(1).nullish(),
+  creator_template_version: z17.number().int().positive().nullish(),
+  creator_name: z17.string().min(1).nullish(),
   published_at: Timestamp
 });
 
 // ../core/src/schema/vault.ts
-import { z as z16 } from "zod";
-var VaultCredentialKindSchema = z16.enum(["env_var", "static_bearer", "mcp_oauth"]);
-var VaultSchema = z16.object({
+import { z as z18 } from "zod";
+var VaultCredentialKindSchema = z18.enum(["env_var", "static_bearer", "mcp_oauth"]);
+var VaultSchema = z18.object({
   id: idOf("vlt"),
-  object: z16.literal("vault"),
+  object: z18.literal("vault"),
   identity_id: idOf("idn").nullable(),
-  display_name: z16.string().min(1).max(128),
-  credential_count: z16.number().int().nonnegative(),
+  display_name: z18.string().min(1).max(128),
+  credential_count: z18.number().int().nonnegative(),
   created_at: Timestamp
 });
-var VaultCredentialSchema = z16.object({
+var VaultCredentialSchema = z18.object({
   id: idOf("vcr"),
-  object: z16.literal("vault_credential"),
+  object: z18.literal("vault_credential"),
   vault_id: idOf("vlt"),
   kind: VaultCredentialKindSchema,
   /** For `env_var`, the environment variable name. For the MCP kinds, a display label. */
-  key: z16.string().min(1).max(128),
+  key: z18.string().min(1).max(128),
   /** The exact destination host an `env_var` credential is bound to. Never a wildcard. */
-  host: z16.string().nullable(),
+  host: z18.string().nullable(),
   /** The exact MCP server URL an `mcp_*` token is matched to. */
-  mcp_server_url: z16.url().nullable(),
-  placeholder_ref: z16.string(),
+  mcp_server_url: z18.url().nullable(),
+  placeholder_ref: z18.string(),
   expires_at: Timestamp.nullable(),
   last_injected_at: Timestamp.nullable(),
   created_at: Timestamp
 });
 
-// ../core/src/schema/social.ts
-import { z as z17 } from "zod";
-var SOCIAL_PLATFORMS = [
-  "bluesky",
-  "facebook",
-  "instagram",
-  "linkedin",
-  "mastodon",
-  "pinterest",
-  "reddit",
-  "threads",
-  "tiktok",
-  "x",
-  "youtube"
-];
-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 = z17.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 = z17.enum(SOCIAL_PLATFORMS);
-var SocialTextPlatformSchema = z17.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 = z17.object({
-  id: z17.string().min(1),
-  object: z17.literal("social_account"),
-  identity_id: idOf("idn"),
-  platform: SocialPlatformSchema,
-  username: z17.string().nullable(),
-  display_name: z17.string().nullable(),
-  avatar_url: z17.url().nullable(),
-  connected_at: Timestamp.nullable()
-});
-var SocialPostStatusSchema = z17.enum([
-  "draft",
-  "scheduled",
-  "processing",
-  "posted",
-  "failed",
-  "deleted"
-]);
-var SocialPostSchema = z17.object({
-  id: z17.string().min(1),
-  object: z17.literal("social_post"),
-  identity_id: idOf("idn"),
-  title: z17.string(),
-  platforms: z17.array(SocialPlatformSchema),
-  status: SocialPostStatusSchema,
-  scheduled_at: Timestamp.nullable(),
-  posted_at: Timestamp.nullable(),
-  error: z17.string().nullable()
-});
-var SocialUploadSchema = z17.object({
-  id: z17.string().min(1),
-  object: z17.literal("social_upload"),
-  identity_id: idOf("idn"),
-  type: z17.enum(["image", "video", "document"]),
-  url: z17.url().nullable()
-});
-var SocialAnalyticsSchema = z17.object({
-  object: z17.literal("social_analytics"),
-  identity_id: idOf("idn"),
-  resource_id: z17.string().min(1),
-  platform: SocialPlatformSchema.nullable(),
-  data: z17.unknown()
-});
-var SocialCommentSchema = z17.object({
-  id: z17.string().min(1),
-  object: z17.literal("social_comment"),
-  identity_id: idOf("idn"),
-  post_id: z17.string().min(1),
-  platforms: z17.array(SocialPlatformSchema),
-  status: SocialPostStatusSchema,
-  posted_at: Timestamp.nullable(),
-  data: z17.unknown()
-});
-
 // ../core/src/schema/handoff.ts
-import { z as z18 } from "zod";
-var HandoffRequestSchema = z18.object({
-  agent: z18.string().min(1),
-  message: z18.string().min(1),
-  handoff_key: z18.string().min(1).max(128).optional(),
-  budget_micro_usd: z18.number().int().positive().optional()
-});
-var HandoffSchema = z18.object({
-  object: z18.literal("handoff"),
+import { z as z19 } from "zod";
+var MAX_HANDOFF_TARGETS = 6;
+var HandoffRequestSchema = z19.object({
+  agent: z19.string().min(1),
+  message: z19.string().min(1),
+  handoff_key: z19.string().min(1).max(128).optional(),
+  budget_micro_usd: z19.number().int().positive().optional()
+});
+var HandoffSchema = z19.object({
+  object: z19.literal("handoff"),
   session_id: idOf("ses"),
-  status: z18.enum(["queued", "already_running"]),
-  handoff_key: z18.string().nullable()
-});
-var SessionHandoffSchema = z18.object({
+  status: z19.enum(["queued", "already_running"]),
+  handoff_key: z19.string().nullable()
+});
+var SessionHandoffRequestSchema = z19.object({
+  agents: z19.array(z19.string().min(1)).min(1).max(MAX_HANDOFF_TARGETS),
+  message: z19.string().min(1),
+  handoff_key: z19.string().min(1).max(128).optional(),
+  budget_micro_usd: z19.number().int().positive().optional()
+});
+var HandoffRefusalSchema = z19.object({
+  object: z19.literal("handoff_refusal"),
+  agent: z19.string(),
+  code: z19.string(),
+  message: z19.string()
+});
+var HandoffBatchSchema = z19.object({
+  object: z19.literal("handoff_batch"),
+  handoffs: z19.array(HandoffSchema.extend({ agent_id: idOf("agt") })),
+  refusals: z19.array(HandoffRefusalSchema)
+});
+var SessionHandoffSchema = z19.object({
   from_session: idOf("ses"),
   from_agent: idOf("agt"),
-  key: z18.string().nullable(),
-  depth: z18.number().int().positive()
+  key: z19.string().nullable(),
+  depth: z19.number().int().positive()
+});
+var ChannelBriefSchema = z19.object({
+  root_session_id: idOf("ses"),
+  name: z19.string().min(1),
+  members: z19.array(z19.string().min(1))
+});
+var ChannelPostRequestSchema = z19.object({
+  message: z19.string().min(1).max(2e4)
+});
+var ChannelPostSchema = z19.object({
+  object: z19.literal("channel_post"),
+  root_session_id: idOf("ses"),
+  queued: z19.boolean()
 });
 
 // ../core/src/schema/media.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var MEDIA_JOB_KINDS = ["video", "clip", "transcription"];
-var MediaJobKindSchema = z19.enum(MEDIA_JOB_KINDS);
-var MediaJobStatusSchema = z19.enum(["queued", "processing", "completed", "failed"]);
-var PublicUrl = z19.string().url().startsWith("http");
-var Score = z19.number().int().min(0).max(100);
-var Seconds = z19.number().nonnegative();
-var VideoResultSchema = z19.object({
-  files: z19.array(
-    z19.object({
+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(
+    z20.object({
       file_id: idOf("fil"),
-      content_type: z19.string(),
-      width: z19.number().int().positive().nullable(),
-      height: z19.number().int().positive().nullable(),
+      content_type: z20.string(),
+      width: z20.number().int().positive().nullable(),
+      height: z20.number().int().positive().nullable(),
       duration_seconds: Seconds.nullable()
     })
   )
 });
-var ViralityScoreSchema = z19.object({
+var ViralityScoreSchema = z20.object({
   total: Score,
   shareability: Score,
   hook_strength: Score,
   story_quality: Score,
   emotional_impact: Score
 });
-var ClipResultSchema = z19.object({
-  clips: z19.array(
-    z19.object({
+var ClipResultSchema = z20.object({
+  clips: z20.array(
+    z20.object({
       file_id: idOf("fil"),
-      title: z19.string(),
+      title: z20.string(),
       start_seconds: Seconds,
       end_seconds: Seconds,
       duration_seconds: Seconds,
@@ -1679,189 +1895,189 @@ var ClipResultSchema = z19.object({
     })
   )
 });
-var TranscriptSchema = z19.object({
-  text: z19.string(),
-  language: z19.string().nullable(),
+var TranscriptSchema = z20.object({
+  text: z20.string(),
+  language: z20.string().nullable(),
   duration_seconds: Seconds.nullable(),
-  segments: z19.array(z19.object({ start_seconds: Seconds, end_seconds: Seconds, text: z19.string() }))
+  segments: z20.array(z20.object({ start_seconds: Seconds, end_seconds: Seconds, text: z20.string() }))
 });
-var MediaJobResultSchema = z19.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
-var MediaJobSchema = z19.object({
+var MediaJobResultSchema = z20.union([VideoResultSchema, ClipResultSchema, TranscriptSchema]);
+var MediaJobSchema = z20.object({
   id: idOf("med"),
-  object: z19.literal("media_job"),
+  object: z20.literal("media_job"),
   kind: MediaJobKindSchema,
   status: MediaJobStatusSchema,
-  model: z19.string().nullable(),
-  input: z19.record(z19.string(), z19.unknown()),
+  model: z20.string().nullable(),
+  input: z20.record(z20.string(), z20.unknown()),
   result: MediaJobResultSchema.nullable(),
-  error: z19.object({ code: z19.string(), message: z19.string() }).nullable(),
+  error: z20.object({ code: z20.string(), message: z20.string() }).nullable(),
   cost_micro_usd: MicroUsdField.nullable(),
   session_id: idOf("ses").nullable(),
   created_at: Timestamp,
   completed_at: Timestamp.nullable()
 });
-var ImageRequestSchema = z19.object({
-  model: z19.string().min(1).optional(),
-  prompt: z19.string().min(1),
-  image_urls: z19.array(PublicUrl).max(4).optional(),
-  aspect_ratio: z19.string().optional(),
-  seed: z19.number().int().optional(),
-  n: z19.number().int().min(1).max(4).default(1)
-});
-var VideoRequestSchema = z19.object({
-  model: z19.string().min(1),
-  prompt: z19.string().min(1),
-  image_urls: z19.array(PublicUrl).max(1).optional(),
-  aspect_ratio: z19.string().optional(),
-  seed: z19.number().int().optional(),
-  seconds: z19.number().int().min(1).max(60).optional()
-});
-var ImageGenerationSchema = z19.object({
-  object: z19.literal("image_generation"),
-  model: z19.string(),
-  files: z19.array(FileSchema),
+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),
   cost_micro_usd: MicroUsdField
 });
-var ClipLength = z19.number().int().min(5).max(180);
-var ClipRequestSchema = z19.object({
+var ClipLength = z20.number().int().min(5).max(180);
+var ClipRequestSchema = z20.object({
   video_url: PublicUrl,
-  aspect_ratio: z19.enum(["9:16", "16:9"]).default("9:16"),
-  remove_silence: z19.boolean().default(false),
-  caption_preset: z19.enum(["none", "clean", "bold", "karaoke"]).default("none"),
-  language: z19.string().min(2).optional(),
+  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(),
   min_seconds: ClipLength.default(15),
   max_seconds: ClipLength.default(60),
-  title: z19.string().min(1).optional()
+  title: z20.string().min(1).optional()
 });
-var AudioFormatSchema = z19.enum(["mp3", "wav", "ogg"]);
-var TranscriptionRequestSchema = z19.object({
-  model: z19.string().min(1).optional(),
+var AudioFormatSchema = z20.enum(["mp3", "wav", "ogg"]);
+var TranscriptionRequestSchema = z20.object({
+  model: z20.string().min(1).optional(),
   file_id: idOf("fil").optional(),
   url: PublicUrl.optional(),
-  language: z19.string().min(2).optional(),
-  timestamps: z19.boolean().default(true)
+  language: z20.string().min(2).optional(),
+  timestamps: z20.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 = z19.object({
-  model: z19.string().min(1).optional(),
-  text: z19.string().min(1).max(4096),
-  voice: z19.string().min(1).optional(),
+var SpeechRequestSchema = z20.object({
+  model: z20.string().min(1).optional(),
+  text: z20.string().min(1).max(4096),
+  voice: z20.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3"),
-  speed: z19.number().min(0.5).max(2).optional()
+  speed: z20.number().min(0.5).max(2).optional()
 });
-var SpeechToSpeechRequestSchema = z19.object({
-  model: z19.string().min(1).optional(),
+var SpeechToSpeechRequestSchema = z20.object({
+  model: z20.string().min(1).optional(),
   file_id: idOf("fil"),
-  voice: z19.string().min(1).optional(),
+  voice: z20.string().min(1).optional(),
   format: AudioFormatSchema.default("mp3")
 });
-var SpeechGenerationSchema = z19.object({
-  object: z19.literal("speech_generation"),
-  model: z19.string(),
+var SpeechGenerationSchema = z20.object({
+  object: z20.literal("speech_generation"),
+  model: z20.string(),
   file: FileSchema,
   duration_seconds: Seconds.nullable(),
   cost_micro_usd: MicroUsdField
 });
 
 // ../core/src/schema/app-data.ts
-import { z as z20 } from "zod";
-var DbTableSchema = z20.object({
-  object: z20.literal("db_table"),
-  name: z20.string(),
-  schema: z20.string().default("public"),
-  rows: z20.number().int().nonnegative().nullable(),
-  size_bytes: z20.number().int().nonnegative().nullable()
-});
-var DbMigrationSchema = z20.object({
+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({
   id: idOf("dbm"),
-  object: z20.literal("db_migration"),
-  name: z20.string(),
-  sha256: z20.string().regex(/^[0-9a-f]{64}$/),
+  object: z21.literal("db_migration"),
+  name: z21.string(),
+  sha256: z21.string().regex(/^[0-9a-f]{64}$/),
   applied_at: Timestamp,
-  statements: z20.number().int().nonnegative()
+  statements: z21.number().int().nonnegative()
 });
-var ApplyDbMigrationSchema = z20.object({
-  name: z20.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
-  sql: z20.string().min(1)
+var ApplyDbMigrationSchema = z21.object({
+  name: z21.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/),
+  sql: z21.string().min(1)
 });
 var DB_REST_METHODS = ["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD"];
-var DbRestMethodSchema = z20.enum(DB_REST_METHODS);
+var DbRestMethodSchema = z21.enum(DB_REST_METHODS);
 var BUCKET_NAME = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
-var BucketSchema = z20.object({
-  object: z20.literal("bucket"),
-  name: z20.string().regex(BUCKET_NAME),
-  public: z20.boolean(),
+var BucketSchema = z21.object({
+  object: z21.literal("bucket"),
+  name: z21.string().regex(BUCKET_NAME),
+  public: z21.boolean(),
   created_at: Timestamp
 });
-var CreateBucketSchema = z20.object({
-  name: z20.string().regex(BUCKET_NAME, { error: "3\u201363 lowercase letters, digits and hyphens" }),
-  public: z20.boolean().default(false)
-});
-var StorageObjectSchema = z20.object({
-  object: z20.literal("storage_object"),
-  bucket: z20.string(),
-  key: z20.string().min(1),
-  size_bytes: z20.number().int().nonnegative(),
-  content_type: z20.string(),
-  etag: z20.string().nullable(),
+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(),
   updated_at: Timestamp
 });
-var SignedUrlMethodSchema = z20.enum(["PUT", "GET"]);
-var SignedUrlSchema = z20.object({
-  object: z20.literal("signed_url"),
-  url: z20.string().url(),
+var SignedUrlMethodSchema = z21.enum(["PUT", "GET"]);
+var SignedUrlSchema = z21.object({
+  object: z21.literal("signed_url"),
+  url: z21.string().url(),
   method: SignedUrlMethodSchema,
   expires_at: Timestamp
 });
-var CreateUploadUrlSchema = z20.object({
-  content_type: z20.string().min(1),
-  expires_seconds: z20.number().int().min(60).max(3600).default(900)
+var CreateUploadUrlSchema = z21.object({
+  content_type: z21.string().min(1),
+  expires_seconds: z21.number().int().min(60).max(3600).default(900)
 });
 
 // ../core/src/schema/stock-photo.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var STOCK_PHOTO_ORIENTATIONS = ["landscape", "portrait", "square"];
 var STOCK_PHOTO_SIZES = ["small", "medium", "large"];
-var StockPhotoQuerySchema = z21.object({
-  query: z21.string().min(1).max(200),
-  count: z21.coerce.number().int().min(1).max(30).default(10),
-  orientation: z21.enum(STOCK_PHOTO_ORIENTATIONS).optional(),
-  color: z21.string().min(1).max(32).optional(),
-  size: z21.enum(STOCK_PHOTO_SIZES).optional()
-});
-var StockPhotoSchema = z21.object({
-  object: z21.literal("stock_photo"),
-  id: z21.string().min(1),
-  width: z21.number().int().positive(),
-  height: z21.number().int().positive(),
-  url: z21.string().url(),
-  preview_url: z21.string().url(),
-  alt: z21.string().nullable(),
-  photographer: z21.string().nullable(),
-  attribution_url: z21.string().url().nullable(),
-  dominant_color: z21.string().nullable()
+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()
 });
 
 // ../core/src/schema/creator.ts
-import { z as z22 } from "zod";
-var CreatorCodeSchema = z22.string().regex(/^[a-z0-9]{3,24}$/, "3 to 24 lowercase letters or digits");
-var PayoutMethodSchema = z22.enum(["wise", "paypal"]);
-var PayoutDetailsSchema = z22.object({
+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({
   method: PayoutMethodSchema,
-  account: z22.string().min(1).max(320)
+  account: z23.string().min(1).max(320)
 });
-var CreatorStatusSchema = z22.enum(["active", "suspended"]);
-var CreatorSchema = z22.object({
+var CreatorStatusSchema = z23.enum(["active", "suspended"]);
+var CreatorSchema = z23.object({
   id: idOf("crt"),
-  object: z22.literal("creator"),
-  email: z22.email(),
-  display_name: z22.string().min(1).max(80),
+  object: z23.literal("creator"),
+  email: z23.email(),
+  display_name: z23.string().min(1).max(80),
   code: CreatorCodeSchema,
   status: CreatorStatusSchema,
   payout: PayoutDetailsSchema.nullable(),
-  clicks: z22.number().int().nonnegative(),
+  clicks: z23.number().int().nonnegative(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -1869,28 +2085,28 @@ var IdentityCreatorSchema = CreatorSchema.pick({
   id: true,
   status: true
 });
-var CreatorApplicationStatusSchema = z22.enum([
+var CreatorApplicationStatusSchema = z23.enum([
   "pending",
   "approved",
   "rejected"
 ]);
-var CreatorApplicationSchema = z22.object({
+var CreatorApplicationSchema = z23.object({
   id: idOf("cra"),
-  object: z22.literal("creator_application"),
-  email: z22.email(),
-  display_name: z22.string().min(1).max(80),
-  pitch: z22.string().min(1).max(2e3),
-  links: z22.array(z22.url({ protocol: /^https$/ })).max(5),
+  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),
   status: CreatorApplicationStatusSchema,
-  note: z22.string().nullable(),
+  note: z23.string().nullable(),
   creator_id: idOf("crt").nullable(),
   created_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var ReferralStatusSchema = z22.enum(["pending", "active", "expired"]);
-var ReferralSchema = z22.object({
+var ReferralStatusSchema = z23.enum(["pending", "active", "expired"]);
+var ReferralSchema = z23.object({
   id: idOf("crf"),
-  object: z22.literal("referral"),
+  object: z23.literal("referral"),
   creator_id: idOf("crt"),
   organization_id: idOf("org"),
   status: ReferralStatusSchema,
@@ -1898,16 +2114,16 @@ var ReferralSchema = z22.object({
   first_paid_at: Timestamp.nullable(),
   commission_until: Timestamp.nullable()
 });
-var CommissionKindSchema = z22.enum(["referral", "template"]);
-var CommissionStatusSchema = z22.enum([
+var CommissionKindSchema = z23.enum(["referral", "template"]);
+var CommissionStatusSchema = z23.enum([
   "pending",
   "available",
   "claimed",
   "paid"
 ]);
-var CommissionSchema = z22.object({
+var CommissionSchema = z23.object({
   id: idOf("crc"),
-  object: z22.literal("commission"),
+  object: z23.literal("commission"),
   creator_id: idOf("crt"),
   kind: CommissionKindSchema,
   referral_id: idOf("crf").nullable(),
@@ -1920,18 +2136,18 @@ var CommissionSchema = z22.object({
   available_at: Timestamp,
   payout_id: idOf("crp").nullable()
 });
-var PayoutStatusSchema = z22.enum(["requested", "paid", "rejected"]);
-var PayoutSchema = z22.object({
+var PayoutStatusSchema = z23.enum(["requested", "paid", "rejected"]);
+var PayoutSchema = z23.object({
   id: idOf("crp"),
-  object: z22.literal("payout"),
+  object: z23.literal("payout"),
   creator_id: idOf("crt"),
   amount_micro_usd: MicroUsdField.positive(),
-  currency: z22.literal("USD"),
+  currency: z23.literal("USD"),
   method: PayoutMethodSchema,
-  account: z22.string().min(1),
+  account: z23.string().min(1),
   status: PayoutStatusSchema,
-  reference: z22.string().nullable(),
-  note: z22.string().nullable(),
+  reference: z23.string().nullable(),
+  note: z23.string().nullable(),
   requested_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
@@ -1943,100 +2159,100 @@ var CREATOR_PROGRAM = {
   attribution_days: 30,
   minimum_payout_micro_usd: 2e7
 };
-var CreatorTemplateSlugSchema = z22.string().max(32).regex(
+var CreatorTemplateSlugSchema = z23.string().max(32).regex(
   /^[a-z0-9]+(-[a-z0-9]+)*$/,
   "lowercase letters, digits and single dashes"
 );
-var CreatorSkillSchema = z22.object({
-  slug: z22.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  body: z22.string().min(1).max(64 * 1024)
+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 CreatorDeclarationSchema = z22.object({
-  agents: z22.array(z22.unknown()),
-  questions: z22.array(z22.unknown()),
-  skills: z22.array(CreatorSkillSchema).max(16)
+var CreatorDeclarationSchema = z23.object({
+  agents: z23.array(z23.unknown()),
+  questions: z23.array(z23.unknown()),
+  skills: z23.array(CreatorSkillSchema).max(16)
 });
-var CreatorTemplateVersionStatusSchema = z22.enum([
+var CreatorTemplateVersionStatusSchema = z23.enum([
   "in_review",
   "approved",
   "changes_requested"
 ]);
-var VersionNumber = z22.number().int().positive();
-var CreatorTemplateSchema = z22.object({
+var VersionNumber = z23.number().int().positive();
+var CreatorTemplateSchema = z23.object({
   id: idOf("ctp"),
-  object: z22.literal("creator_template"),
+  object: z23.literal("creator_template"),
   creator_id: idOf("crt"),
-  blueprint: z22.string().min(1),
-  base_template: z22.string().min(1),
+  blueprint: z23.string().min(1),
+  base_template: z23.string().min(1),
   slug: CreatorTemplateSlugSchema,
-  template: z22.string().min(1).max(64),
-  name: z22.string().min(1).max(80),
-  description: z22.string().max(2e3),
+  template: z23.string().min(1).max(64),
+  name: z23.string().min(1).max(80),
+  description: z23.string().max(2e3),
   declaration: CreatorDeclarationSchema,
   published_version: VersionNumber.nullable(),
-  latest_version: z22.object({
+  latest_version: z23.object({
     version: VersionNumber,
     status: CreatorTemplateVersionStatusSchema
   }).nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreatorTemplateVersionSchema = z22.object({
-  object: z22.literal("creator_template_version"),
+var CreatorTemplateVersionSchema = z23.object({
+  object: z23.literal("creator_template_version"),
   template_id: idOf("ctp"),
   version: VersionNumber,
   declaration: CreatorDeclarationSchema,
   status: CreatorTemplateVersionStatusSchema,
-  note: z22.string().nullable(),
+  note: z23.string().nullable(),
   artifact_id: idOf("bpa").nullable(),
   submitted_at: Timestamp,
   decided_at: Timestamp.nullable()
 });
-var CreatorBalanceSchema = z22.object({
-  object: z22.literal("creator_balance"),
+var CreatorBalanceSchema = z23.object({
+  object: z23.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: z22.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
+  minimum_payout_micro_usd: z23.literal(CREATOR_PROGRAM.minimum_payout_micro_usd)
 });
-var ReferralClickSchema = z22.object({
-  object: z22.literal("referral_click"),
+var ReferralClickSchema = z23.object({
+  object: z23.literal("referral_click"),
   code: CreatorCodeSchema,
-  creator: z22.object({ display_name: z22.string().min(1) }),
+  creator: z23.object({ display_name: z23.string().min(1) }),
   expires_at: Timestamp
 });
-var Day = z22.iso.date();
-var CreatorAnalyticsSchema = z22.object({
-  object: z22.literal("creator_analytics"),
-  days: z22.number().int().min(1).max(90),
+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: z22.number().int().nonnegative(),
-  referrals: z22.number().int().nonnegative(),
-  installs: z22.number().int().nonnegative(),
-  active_installs: z22.number().int().nonnegative(),
-  usage_by_day: z22.array(
-    z22.object({ day: Day, debit_micro_usd: MicroUsdField.nonnegative() })
+  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() })
   ),
-  commission_micro_usd: z22.object({
+  commission_micro_usd: z23.object({
     pending: MicroUsdField.nonnegative(),
     available: MicroUsdField.nonnegative(),
     claimed: MicroUsdField.nonnegative(),
     paid: MicroUsdField.nonnegative()
   }),
-  commissions_by_template: z22.array(
-    z22.object({
+  commissions_by_template: z23.array(
+    z23.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: z22.array(z22.object({ install_id: idOf("bpi"), from: Day, until: Day }))
+  install_windows: z23.array(z23.object({ install_id: idOf("bpi"), from: Day, until: Day }))
 });
 
 // ../core/src/schema/legal.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var LEGAL_MEMBER_STATUSES = [
   "pending",
   "link_ready",
@@ -2046,16 +2262,16 @@ var LEGAL_MEMBER_STATUSES = [
   "verified",
   "failed"
 ];
-var LegalMemberStatusSchema = z23.enum(LEGAL_MEMBER_STATUSES);
+var LegalMemberStatusSchema = z24.enum(LEGAL_MEMBER_STATUSES);
 var LEGAL_VERIFICATION_STATUSES = ["in_progress", "pending_review", "verified", "failed"];
-var LegalVerificationStatusSchema = z23.enum(LEGAL_VERIFICATION_STATUSES);
+var LegalVerificationStatusSchema = z24.enum(LEGAL_VERIFICATION_STATUSES);
 var LEGAL_COMPANY_STATUSES = ["awaiting_payment", "paid", "submitted", "formed", "failed"];
-var LegalCompanyStatusSchema = z23.enum(LEGAL_COMPANY_STATUSES);
+var LegalCompanyStatusSchema = z24.enum(LEGAL_COMPANY_STATUSES);
 var LEGAL_DOCUMENT_KINDS = ["articles", "ein_letter", "operating_agreement", "other"];
-var LegalDocumentKindSchema = z23.enum(LEGAL_DOCUMENT_KINDS);
-var LegalMemberRoleSchema = z23.enum(["primary", "secondary"]);
-var LegalEinStatusSchema = z23.enum(["none", "pending", "issued"]);
-var LegalRequiredActionKindSchema = z23.enum(["signature", "information", "payment", "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 US_STATES = [
   "AL",
   "AK",
@@ -2109,105 +2325,105 @@ var US_STATES = [
   "WI",
   "WY"
 ];
-var UsStateSchema = z23.enum(US_STATES);
-var LegalMemberInputSchema = z23.object({
-  first_name: z23.string().min(1).max(128),
-  last_name: z23.string().min(1).max(128),
-  email: z23.string().min(1).max(320),
+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),
   role: LegalMemberRoleSchema,
-  is_responsible_party: z23.boolean(),
-  ownership_percent: z23.number().int()
+  is_responsible_party: z24.boolean(),
+  ownership_percent: z24.number().int()
 });
 var LegalMemberSchema = LegalMemberInputSchema.extend({
   id: idOf("lgm"),
-  object: z23.literal("legal_member"),
+  object: z24.literal("legal_member"),
   verification_id: idOf("lgv"),
   status: LegalMemberStatusSchema,
-  link_url: z23.url().nullable(),
+  link_url: z24.url().nullable(),
   link_expires_at: Timestamp.nullable(),
   completed_at: Timestamp.nullable()
 });
-var LegalVerificationSchema = z23.object({
+var LegalVerificationSchema = z24.object({
   id: idOf("lgv"),
-  object: z23.literal("legal_verification"),
+  object: z24.literal("legal_verification"),
   identity_id: idOf("idn"),
   status: LegalVerificationStatusSchema,
-  members: z23.array(LegalMemberSchema),
-  ready_for_formation: z23.boolean(),
+  members: z24.array(LegalMemberSchema),
+  ready_for_formation: z24.boolean(),
   started_at: Timestamp,
   completed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var StartLegalVerificationSchema = z23.object({ members: z23.array(LegalMemberInputSchema) });
-var CompleteLegalMemberSchema = z23.object({ token: z23.string().min(1) });
-var LegalNameOptionSchema = z23.object({ name: z23.string().min(1).max(200), ending: z23.literal("LLC") });
-var LegalMailingAddressSchema = z23.object({
-  line1: z23.string().min(1).max(200),
-  line2: z23.string().max(200).nullable(),
-  city: z23.string().min(1).max(100),
+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),
   state: UsStateSchema,
-  postal_code: z23.string().min(1).max(16),
-  country: z23.literal("US")
+  postal_code: z24.string().min(1).max(16),
+  country: z24.literal("US")
 });
-var LegalRequiredActionSchema = z23.object({
+var LegalRequiredActionSchema = z24.object({
   kind: LegalRequiredActionKindSchema,
-  description: z23.string(),
-  url: z23.url().nullable()
+  description: z24.string(),
+  url: z24.url().nullable()
 });
 var LEGAL_DESCRIPTION_MAX = 50;
-var CreateLegalCompanySchema = z23.object({
+var CreateLegalCompanySchema = z24.object({
   verification_id: idOf("lgv"),
   state: UsStateSchema,
-  name_options: z23.array(z23.string().min(1).max(200)).min(1).max(3),
-  naics_code: z23.string().regex(/^\d{2,6}$/),
-  description: z23.string().min(1).max(LEGAL_DESCRIPTION_MAX),
+  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),
   mailing_address: LegalMailingAddressSchema
 });
 var LegalCompanySchema = CreateLegalCompanySchema.omit({ name_options: true }).extend({
   id: idOf("lgc"),
-  object: z23.literal("legal_company"),
+  object: z24.literal("legal_company"),
   identity_id: idOf("idn"),
   status: LegalCompanyStatusSchema,
-  entity_type: z23.literal("llc"),
-  name_options: z23.array(LegalNameOptionSchema),
-  legal_name: z23.string().nullable(),
+  entity_type: z24.literal("llc"),
+  name_options: z24.array(LegalNameOptionSchema),
+  legal_name: z24.string().nullable(),
   ein_status: LegalEinStatusSchema,
   price_micro_usd: MicroUsdField,
-  required_actions: z23.array(LegalRequiredActionSchema),
-  failure_reason: z23.string().max(256).nullable(),
+  required_actions: z24.array(LegalRequiredActionSchema),
+  failure_reason: z24.string().max(256).nullable(),
   submitted_at: Timestamp.nullable(),
   formed_at: Timestamp.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var LegalDocumentSchema = z23.object({
+var LegalDocumentSchema = z24.object({
   id: idOf("lgd"),
-  object: z23.literal("legal_document"),
+  object: z24.literal("legal_document"),
   company_id: idOf("lgc"),
   kind: LegalDocumentKindSchema,
-  name: z23.string(),
+  name: z24.string(),
   created_at: Timestamp
 });
-var LegalDocumentLinkSchema = z23.object({
-  object: z23.literal("legal_document_link"),
-  url: z23.url(),
+var LegalDocumentLinkSchema = z24.object({
+  object: z24.literal("legal_document_link"),
+  url: z24.url(),
   expires_at: Timestamp
 });
-var NaicsCodeSchema = z23.object({
-  object: z23.literal("naics_code"),
-  code: z23.string().regex(/^\d{2,6}$/),
-  title: z23.string()
+var NaicsCodeSchema = z24.object({
+  object: z24.literal("naics_code"),
+  code: z24.string().regex(/^\d{2,6}$/),
+  title: z24.string()
 });
-var LegalStateSchema = z23.object({
-  object: z23.literal("legal_state"),
+var LegalStateSchema = z24.object({
+  object: z24.literal("legal_state"),
   code: UsStateSchema,
-  name: z23.string(),
+  name: z24.string(),
   formation_fee_micro_usd: MicroUsdField
 });
-var LegalWebhookEventSchema = z23.object({
-  provider_session_ref: z23.string().min(1),
-  status: z23.enum(["verified", "failed", "pending_review"]),
+var LegalWebhookEventSchema = z24.object({
+  provider_session_ref: z24.string().min(1),
+  status: z24.enum(["verified", "failed", "pending_review"]),
   metadata: Metadata
 });
 var LLC_ENDING = /\s*(?:,\s*)?(?:l\.?l\.?c\.?|limited\s+liability\s+company)\s*$/i;
@@ -2218,186 +2434,243 @@ function canonicalName(raw) {
 }
 
 // ../core/src/schema/wallet.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var WALLET_NETWORKS = ["eip155:84532", "eip155:8453"];
-var WalletNetworkSchema = z24.enum(WALLET_NETWORKS);
+var WalletNetworkSchema = z25.enum(WALLET_NETWORKS);
 var DEFAULT_WALLET_NETWORK = "eip155:84532";
-var WalletSelectSchema = z24.object({ network: WalletNetworkSchema.optional() });
+var WalletSelectSchema = z25.object({ network: WalletNetworkSchema.optional() });
 var WALLET_STATUSES = ["active", "frozen", "swept"];
-var WalletStatusSchema = z24.enum(WALLET_STATUSES);
+var WalletStatusSchema = z25.enum(WALLET_STATUSES);
 var WALLET_TRANSACTION_KINDS = ["fund", "transfer", "pay", "sweep"];
-var WalletTransactionKindSchema = z24.enum(WALLET_TRANSACTION_KINDS);
+var WalletTransactionKindSchema = z25.enum(WALLET_TRANSACTION_KINDS);
 var WALLET_TRANSACTION_STATUSES = ["pending", "confirmed", "failed"];
-var WalletTransactionStatusSchema = z24.enum(WALLET_TRANSACTION_STATUSES);
-var WalletDirectionSchema = z24.enum(["in", "out"]);
-var WalletFundSourceSchema = z24.enum(["faucet", "treasury"]);
-var EvmAddressSchema = z24.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x address");
-var TxHashSchema = z24.string().regex(/^0x[0-9a-fA-F]{64}$/, "expected a 0x transaction hash");
-var WalletPolicySchema = z24.object({
+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({
   per_tx_cap_micro_usd: MicroUsdField.nonnegative(),
   daily_cap_micro_usd: MicroUsdField.positive().nullable(),
   low_balance_micro_usd: MicroUsdField.nonnegative().nullable()
 });
-var WalletSchema = z24.object({
+var WalletSchema = z25.object({
   id: idOf("wlt"),
-  object: z24.literal("wallet"),
+  object: z25.literal("wallet"),
   identity_id: idOf("idn"),
   status: WalletStatusSchema,
   network: WalletNetworkSchema,
   address: EvmAddressSchema,
-  asset: z24.literal("usdc"),
+  asset: z25.literal("usdc"),
   balance_micro_usd: MicroUsdField,
   policy: WalletPolicySchema,
   spent_today_micro_usd: MicroUsdField,
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var CreateWalletSchema = z24.object({
+var CreateWalletSchema = z25.object({
   network: WalletNetworkSchema.optional(),
   policy: WalletPolicySchema.partial().optional()
 });
 var UpdateWalletPolicySchema = WalletPolicySchema.partial();
-var FundWalletSchema = z24.object({
+var FundWalletSchema = z25.object({
   amount_micro_usd: MicroUsdField.positive(),
   source: WalletFundSourceSchema
 });
-var TransferWalletSchema = z24.object({
-  to: z24.union([EvmAddressSchema, idOf("idn")]),
+var TransferWalletSchema = z25.object({
+  to: z25.union([EvmAddressSchema, idOf("idn")]),
   amount_micro_usd: MicroUsdField.positive(),
-  purpose: z24.string().min(1).max(256)
+  purpose: z25.string().min(1).max(256)
 });
-var SweepWalletSchema = z24.object({ to: EvmAddressSchema.optional() });
-var WalletTransactionSchema = z24.object({
+var SweepWalletSchema = z25.object({ to: EvmAddressSchema.optional() });
+var WalletTransactionSchema = z25.object({
   id: idOf("wtx"),
-  object: z24.literal("wallet_transaction"),
+  object: z25.literal("wallet_transaction"),
   wallet_id: idOf("wlt"),
   kind: WalletTransactionKindSchema,
   direction: WalletDirectionSchema,
   amount_micro_usd: MicroUsdField,
-  counterparty: z24.string().nullable(),
-  origin: z24.string().nullable(),
-  purpose: z24.string().nullable(),
+  counterparty: z25.string().nullable(),
+  origin: z25.string().nullable(),
+  purpose: z25.string().nullable(),
   tx_hash: TxHashSchema.nullable(),
   session_id: idOf("ses").nullable(),
   status: WalletTransactionStatusSchema,
   created_at: Timestamp
 });
-var ListWalletTransactionsSchema = z24.object({
+var ListWalletTransactionsSchema = z25.object({
   kind: WalletTransactionKindSchema.optional(),
   direction: WalletDirectionSchema.optional(),
-  origin: z24.string().optional(),
+  origin: z25.string().optional(),
   since: Timestamp.optional()
 });
-var HttpMethodSchema = z24.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-var WalletQuoteRequestSchema = z24.object({ url: z24.url(), method: HttpMethodSchema.optional() });
-var WalletQuoteSchema = z24.object({
-  object: z24.literal("wallet_quote"),
-  url: z24.url(),
-  payable: z24.boolean(),
+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(),
   network: WalletNetworkSchema.nullable(),
-  asset: z24.literal("usdc").nullable(),
+  asset: z25.literal("usdc").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
   pay_to: EvmAddressSchema.nullable(),
-  description: z24.string().nullable(),
-  max_timeout_seconds: z24.number().int().nullable()
+  description: z25.string().nullable(),
+  max_timeout_seconds: z25.number().int().nullable()
 });
 var WalletPayRequestSchema = WalletQuoteRequestSchema.extend({
   max_amount_micro_usd: MicroUsdField.positive().optional()
 });
 var WALLET_RESPONSE_BODY_MAX = 64 * 1024;
-var WalletPaymentSchema = z24.object({
-  object: z24.literal("wallet_payment"),
-  paid: z24.boolean(),
+var WalletPaymentSchema = z25.object({
+  object: z25.literal("wallet_payment"),
+  paid: z25.boolean(),
   transaction_id: idOf("wtx").nullable(),
   amount_micro_usd: MicroUsdField.nullable(),
-  response_status: z24.number().int(),
-  response_body: z24.string().max(WALLET_RESPONSE_BODY_MAX)
+  response_status: z25.number().int(),
+  response_body: z25.string().max(WALLET_RESPONSE_BODY_MAX)
 });
 
 // ../core/src/schema/cards.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var CARD_STATUSES = ["pending_payment", "issuing", "active", "failed", "cancelled", "refunded"];
-var CardStatusSchema = z25.enum(CARD_STATUSES);
+var CardStatusSchema = z26.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 = z25.object({
+var CardSchema = z26.object({
   id: idOf("vcd"),
-  object: z25.literal("card"),
+  object: z26.literal("card"),
   identity_id: idOf("idn"),
-  kind: z25.literal("prepaid"),
+  kind: z26.literal("prepaid"),
   status: CardStatusSchema,
-  label: z25.string().min(1).max(128),
-  brand: z25.string().nullable(),
-  last4: z25.string().regex(/^\d{4}$/).nullable(),
+  label: z26.string().min(1).max(128),
+  brand: z26.string().nullable(),
+  last4: z26.string().regex(/^\d{4}$/).nullable(),
   load_micro_usd: MicroUsdField,
   spent_micro_usd: MicroUsdField,
-  currency: z25.literal("usd"),
+  currency: z26.literal("usd"),
   expires_at: Timestamp.nullable(),
-  failure_reason: z25.string().max(256).nullable(),
+  failure_reason: z26.string().max(256).nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
-var IssueCardSchema = z25.object({
+var IssueCardSchema = z26.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 = z25.object({
-  object: z25.literal("card_quote"),
+var CardQuoteSchema = z26.object({
+  object: z26.literal("card_quote"),
   load_micro_usd: MicroUsdField,
   price_micro_usd: MicroUsdField,
-  brand: z25.string().nullable(),
+  brand: z26.string().nullable(),
   min_load_micro_usd: MicroUsdField,
   max_load_micro_usd: MicroUsdField
 });
-var CardCredentialsSchema = z25.object({
-  object: z25.literal("card_credentials"),
+var CardCredentialsSchema = z26.object({
+  object: z26.literal("card_credentials"),
   card_id: idOf("vcd"),
-  number: z25.string().min(1),
-  pin: z25.string().nullable(),
-  cvv: z25.string().nullable(),
-  expiry: z25.string().nullable(),
-  url: z25.url().nullable(),
-  instructions: z25.string().nullable(),
+  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(),
   revealed_at: Timestamp
 });
-var CardTransactionSchema = z25.object({
+var CardTransactionSchema = z26.object({
   id: idOf("vct"),
-  object: z25.literal("card_transaction"),
+  object: z26.literal("card_transaction"),
   card_id: idOf("vcd"),
   amount_micro_usd: MicroUsdField,
-  merchant: z25.string().nullable(),
-  description: z25.string().nullable(),
+  merchant: z26.string().nullable(),
+  description: z26.string().nullable(),
   session_id: idOf("ses").nullable(),
   metadata: Metadata,
   created_at: Timestamp
 });
-var LogCardTransactionSchema = z25.object({
+var LogCardTransactionSchema = z26.object({
   amount_micro_usd: MicroUsdField.positive(),
-  merchant: z25.string().max(256).optional(),
-  description: z25.string().max(1024).optional(),
+  merchant: z26.string().max(256).optional(),
+  description: z26.string().max(1024).optional(),
   metadata: Metadata.optional()
 });
-var ListCardsSchema = z25.object({ status: CardStatusSchema.optional() });
+var ListCardsSchema = z26.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({
+  /** 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"),
+  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(),
+  window: WindowSchema,
+  /** The model the reply said served it — where `vetta/auto` resolves — or null if it named none. */
+  resolved_model: z27.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(),
+  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(),
+  content_scope: ProxyTraceContentScopeSchema,
+  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`. */
+  request: ProxyTraceRequestSchema.nullable(),
+  response: ProxyTraceResponseSchema.nullable(),
+  truncated: z27.boolean(),
+  created_at: Timestamp,
+  /** When the reaper deletes this row. Never null: there is no row that is kept forever. */
+  expires_at: Timestamp
+});
 
 // src/define.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 
 // src/roster.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 
 // src/report.ts
 import { ApiError, send } from "@usenaive-sdk/vetta";
-import { z as z26 } from "zod";
+import { z as z28 } 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);
 }
-async function line(name, work) {
+async function line(name, work, id) {
   try {
     return await work();
   } catch (error) {
-    return { name, action: "refused", reason: message(error) };
+    const resolved = id?.();
+    return { name, action: "refused", ...resolved !== void 0 ? { id: resolved } : {}, reason: message(error) };
   }
 }
 var AT_ONCE = 6;
@@ -2429,10 +2702,10 @@ async function absent(work) {
     throw error;
   }
 }
-var PageShape = z26.object({
-  data: z26.array(z26.unknown()),
-  has_more: z26.boolean(),
-  next_cursor: z26.string().nullable()
+var PageShape = z28.object({
+  data: z28.array(z28.unknown()),
+  has_more: z28.boolean(),
+  next_cursor: z28.string().nullable()
 });
 function rowLabel(row) {
   const { object, id } = row ?? {};
@@ -2464,17 +2737,17 @@ async function tombstone(name, current, remove, dryRun) {
 }
 
 // src/roster.ts
-var NAME = z27.string().min(1);
-var RosterNameSchema = z27.union([
+var NAME = z29.string().min(1);
+var RosterNameSchema = z29.union([
   NAME.transform((name) => ({ type: "agent", name })),
-  z27.object({ type: z27.literal("agent"), name: NAME, version: z27.number().int().positive().optional() }),
-  z27.object({ type: z27.literal("self") }),
-  z27.object({ type: z27.literal("advisor"), model: z27.string().min(1) })
+  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) })
 ]);
-var DeclMultiagentField = z27.union([
-  z27.boolean(),
-  z27.object({ ...MultiagentSchema.shape, agents: z27.array(RosterNameSchema).min(1).max(20) }),
-  z27.null()
+var DeclMultiagentField = z29.union([
+  z29.boolean(),
+  z29.object({ ...MultiagentSchema.shape, agents: z29.array(RosterNameSchema).min(1).max(20) }),
+  z29.null()
 ]);
 var hasRoster = (value) => typeof value === "object" && value !== null;
 var rosterNames = (roster) => roster.agents.flatMap((entry) => entry.type === "agent" ? [entry.name] : []);
@@ -2562,65 +2835,65 @@ function chooseTemplate(blueprint, template) {
 var BlueprintRefusal = class extends Error {
   name = "BlueprintRefusal";
 };
-var EnvValueSchema = z28.union([
-  z28.string(),
-  z28.object({ from_env: z28.string().min(1) }),
-  z28.object({ generate: z28.literal(true) })
+var EnvValueSchema = z30.union([
+  z30.string(),
+  z30.object({ from_env: z30.string().min(1) }),
+  z30.object({ generate: z30.literal(true) })
 ]);
-var AppDeclSchema = z28.object({
+var AppDeclSchema = z30.object({
   /** Becomes a hostname, so the grammar is the platform's `APP_NAME` (a DNS label). */
-  name: z28.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
+  name: z30.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
   type: AppTypeSchema,
-  description: z28.string().optional(),
+  description: z30.string().optional(),
   /** A directory whose files are collected and shipped as the app's file-map deployment. */
-  deploy_dir: z28.string().min(1).optional(),
+  deploy_dir: z30.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: z28.record(z28.string().regex(ENV_NAME), EnvValueSchema, { error: "keyed by environment variable name (A-Z, 0-9, _)" }).optional(),
+  env: z30.record(z30.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: z28.boolean().optional(),
+  required: z30.boolean().optional(),
   // core-gaps: U8-database
   /** SQL files applied in order to the app's database after it is provisioned (§37); `fullstack` only. */
-  migrations: z28.array(z28.string().min(1)).optional(),
+  migrations: z30.array(z30.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: z28.array(CreateBucketSchema).optional()
+  buckets: z30.array(CreateBucketSchema).optional()
 });
-var ScheduleDeclSchema = z28.object({
-  cron: z28.string().min(1),
-  timezone: z28.string().min(1).optional(),
+var ScheduleDeclSchema = z30.object({
+  cron: z30.string().min(1),
+  timezone: z30.string().min(1).optional(),
   /** The message every fire opens its session with (`input_template` on the wire). */
-  input: z28.string().min(1),
+  input: z30.string().min(1),
   budget_micro_usd: MicroUsdField.nonnegative(),
-  identity: z28.string().min(1).optional(),
-  enabled: z28.boolean().optional()
+  identity: z30.string().min(1).optional(),
+  enabled: z30.boolean().optional()
 });
 var ToolsDeclSchema = ToolsetSchema;
-var AgentDeclSchema = z28.object({
-  name: z28.string().min(1),
-  model: z28.string().min(1),
+var AgentDeclSchema = z30.object({
+  name: z30.string().min(1),
+  model: z30.string().min(1),
   budget: BudgetSchema,
-  description: z28.string().optional(),
+  description: z30.string().optional(),
   /** Two or three words the studio prints beside the name (§31.5) — "Head of content", not a sentence. */
-  role: z28.string().min(1).optional(),
+  role: z30.string().min(1).optional(),
   /** An install may not leave this agent out of its `selection` (§31.2). Absent means it may. */
-  required: z28.boolean().optional(),
-  system: z28.string().optional(),
+  required: z30.boolean().optional(),
+  system: z30.string().optional(),
   tools: ToolsDeclSchema.optional(),
-  skills: z28.array(SkillRefSchema).optional(),
-  mcp_servers: z28.array(McpServerSchema).optional(),
+  skills: z30.array(SkillRefSchema).optional(),
+  mcp_servers: z30.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: z28.boolean().optional(),
+  structured_output_required: z30.boolean().optional(),
   metadata: Metadata.optional(),
   /** Declared app *names*; `up` resolves them to `app_` ids in `tools.configs.apps` (§29.3). */
-  allowed_apps: z28.array(z28.string()).optional(),
+  allowed_apps: z30.array(z30.string()).optional(),
   /** A declared identity *name*; `up` attaches it after the agent upsert (§22). */
-  identity: z28.string().min(1).optional(),
+  identity: z30.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
@@ -2628,7 +2901,7 @@ var AgentDeclSchema = z28.object({
    */
   handoffs: HandoffsField.optional(),
   /** The agent's deployments as a complete set: declared → owned, and the rest are pruned (ADR-0355). */
-  schedules: z28.array(ScheduleDeclSchema).optional(),
+  schedules: z30.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.
@@ -2641,58 +2914,66 @@ var AgentDeclSchema = z28.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: z28.object({ message: z28.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
+  intake: z30.object({ message: z30.string().min(1), budget_micro_usd: MicroUsdField.nonnegative().optional() }).optional()
 });
-var CredentialDeclSchema = z28.object({
+var CredentialDeclSchema = z30.object({
   kind: VaultCredentialKindSchema,
-  key: z28.string().min(1).max(128),
+  key: z30.string().min(1).max(128),
   /** The one exact destination host an `env_var` is bound to. */
-  host: z28.string().min(1).optional(),
+  host: z30.string().min(1).optional(),
   /** The MCP server URL a `static_bearer` / `mcp_oauth` token is matched to. */
-  mcp_server_url: z28.url().optional(),
-  value: z28.object({ from_env: z28.string().min(1) })
+  mcp_server_url: z30.url().optional(),
+  value: z30.object({ from_env: z30.string().min(1) })
 });
-var VaultDeclSchema = z28.object({
+var VaultDeclSchema = z30.object({
   name: VaultSchema.shape.display_name,
-  identity: z28.string().min(1).optional(),
-  credentials: z28.array(CredentialDeclSchema)
+  identity: z30.string().min(1).optional(),
+  credentials: z30.array(CredentialDeclSchema)
 });
-var SkillDeclSchema = z28.object({
-  slug: z28.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
-  file: z28.string().min(1)
+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 LegalDeclSchema = CreateLegalCompanySchema.pick({
   state: true,
   name_options: true,
   naics_code: true,
   description: true
-}).extend({ label: z28.string().min(1).max(128) });
+}).extend({ label: z30.string().min(1).max(128) });
 var WalletDeclSchema = CreateWalletSchema.or(
-  z28.array(CreateWalletSchema).refine(
+  z30.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({
-  legal: z28.array(LegalDeclSchema).optional(),
+  connections: BlueprintIdentityConnectionsSchema.optional(),
+  legal: z30.array(LegalDeclSchema).optional(),
   wallet: WalletDeclSchema.optional(),
-  cards: z28.array(CardDeclSchema).optional()
-});
-var RemovedSchema = z28.object({
-  apps: z28.array(z28.string().min(1)).default([]),
-  agents: z28.array(z28.string().min(1)).default([]),
-  skills: z28.array(z28.string().min(1)).default([]),
-  identities: z28.array(z28.string().min(1)).default([]),
-  vaults: z28.array(z28.string().min(1)).default([])
-});
-var KeptSchema = z28.object({ agents: z28.array(z28.string().min(1)).default([]) });
-var ProjectSchema = z28.object({
-  name: z28.string().min(1),
+  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),
   /** The machine this project runs: its repo, its screens, its `/api/*` (`template.ts`). */
-  blueprint: z28.string().min(1).optional(),
+  blueprint: z30.string().min(1).optional(),
   /** Which of that blueprint's templates provides the crew; a blueprint with a default may omit it. */
-  template: z28.string().min(1).optional(),
+  template: z30.string().min(1).optional(),
   /**
    * What a person is asked BEFORE the crew is provisioned (`canonical-spec §31.2`).
    *
@@ -2704,19 +2985,21 @@ var ProjectSchema = z28.object({
    *
    * **Configuration only.** A secret is a vault credential or an app secret; neither is an answer.
    */
-  questions: z28.array(QuestionFieldSchema).default([]),
-  skills: z28.array(SkillDeclSchema).default([]),
-  identities: z28.array(IdentityDeclSchema).default([]),
-  vaults: z28.array(VaultDeclSchema).default([]),
-  apps: z28.array(AppDeclSchema).default([]),
-  agents: z28.array(AgentDeclSchema).default([]),
+  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([]),
   /**
    * 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: z28.array(z28.object({ name: z28.string().min(1), role: z28.string().min(1).optional(), description: z28.string().optional() })).optional(),
+  crew_per_client: z30.array(z30.object({ name: z30.string().min(1), role: z30.string().min(1).optional(), description: z30.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([]),
   removed: RemovedSchema.default({ apps: [], agents: [], skills: [], identities: [], vaults: [] }),
   kept: KeptSchema.default({ agents: [] })
 });
@@ -2732,6 +3015,20 @@ function assertUniqueNames(kind, names) {
     seen.add(name);
   }
 }
+function inDependencyOrder(tasks) {
+  const placed = /* @__PURE__ */ new Set();
+  const out = [];
+  while (out.length < tasks.length) {
+    const next = tasks.find((task) => !placed.has(task.key) && (task.blocked_by ?? []).every((key) => placed.has(key)));
+    if (next === void 0) {
+      const stuck = tasks.filter((task) => !placed.has(task.key)).map((task) => `"${task.key}"`);
+      refuse(`tasks ${stuck.join(", ")}: blocked_by forms a cycle \u2014 a card cannot wait on a card that waits on it`);
+    }
+    placed.add(next.key);
+    out.push(next);
+  }
+  return out;
+}
 function deepFreeze(value) {
   if (value !== null && typeof value === "object") {
     for (const child of Object.values(value)) deepFreeze(child);
@@ -2757,8 +3054,8 @@ function parseProject(input) {
   }
   const config = parsed.data;
   applyChoice(config);
-  if (config.template !== void 0 && config.questions.length > 3) {
-    refuse(`template "${config.template}" asks ${config.questions.length} questions, but a template asks at most 3 before anything is provisioned \u2014 a fourth belongs to the crew's first conversation`);
+  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`);
   }
   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]);
@@ -2779,6 +3076,20 @@ 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`);
@@ -2837,6 +3148,21 @@ function parseProject(input) {
       }
     }
   }
+  assertUniqueNames("task", config.tasks.map((task) => task.key));
+  const taskKeys = new Set(config.tasks.map((task) => task.key));
+  for (const task of config.tasks) {
+    if (`${config.name}:${task.key}`.length > 128) {
+      refuse(`task "${task.key}": "${config.name}:${task.key}" is longer than the 128 characters a card key holds \u2014 shorten the key`);
+    }
+    if (task.assignee !== void 0 && !agentNames.has(task.assignee)) {
+      refuse(`task "${task.key}": assignee names "${task.assignee}", but no agent with that name is declared in this project`);
+    }
+    for (const key of task.blocked_by ?? []) {
+      if (key === task.key) refuse(`task "${task.key}": blocked_by names itself \u2014 a card cannot wait on itself`);
+      if (!taskKeys.has(key)) refuse(`task "${task.key}": blocked_by names "${key}", but no task with that key is declared in this project`);
+    }
+  }
+  inDependencyOrder(config.tasks);
   return deepFreeze(config);
 }
 function withTemplate(input, templates) {
@@ -3081,6 +3407,11 @@ async function openIntake(client, agent, decl, dryRun) {
   });
   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`);
@@ -3113,13 +3444,16 @@ async function upsertSchedule(client, agent, decl, current, identityIds, dryRun)
 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,
-      (decl) => line(
+    ...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}`;
@@ -3527,6 +3861,81 @@ async function reportLegal(client, decls, identityId, skipped) {
   );
 }
 
+// src/tasks.ts
+var ORCHESTRATOR_MARKER = "orchestrator";
+var CEO_LABEL = "CEO";
+var CEO_DETAIL = "Hires and directs the crew";
+var CEO_BUDGET = { cap_micro_usd: 5e7, max_task_micro_usd: 5e6, period: "month" };
+var isOrchestrator = (agent) => agent.metadata["role"] === ORCHESTRATOR_MARKER;
+function seated(live, members) {
+  const roster = live?.agents ?? [];
+  const already = new Set(roster.flatMap((entry) => entry.type === "agent" ? [entry.id] : []));
+  const joining = members.filter((id) => !already.has(id)).map((id) => ({ type: "agent", id }));
+  return { type: "coordinator", board: true, agents: [...roster, ...joining] };
+}
+async function ensureOrchestrator(client, existing, members, dryRun) {
+  const current = existing.find(isOrchestrator);
+  const live = current === void 0 ? null : normaliseMultiagent(current.multiagent);
+  const team = seated(live, members);
+  if (current === void 0) {
+    if (dryRun) return { name: CEO_LABEL, action: "created" };
+    const model = (await client.models.list({ window: "immediate", limit: 1 })).data[0];
+    if (model === void 0) throw new BlueprintRefusal("no model is served, so the board's owner cannot be created");
+    const made = await client.agents.create({
+      name: CEO_LABEL,
+      harness: "pi",
+      model: model.id,
+      description: CEO_DETAIL,
+      budget: CEO_BUDGET,
+      metadata: { role: ORCHESTRATOR_MARKER },
+      multiagent: team
+    });
+    return { name: CEO_LABEL, action: "created", id: made.id };
+  }
+  if (live !== null && !changed(team, live)) return { name: current.name, action: "unchanged", id: current.id };
+  if (!dryRun) await client.agents.update(current.id, { multiagent: team });
+  return { name: current.name, action: "updated", id: current.id };
+}
+async function seedTasks(client, config, existing, agents, dryRun, into, skipped) {
+  const members = agents.flatMap((one) => one.id === void 0 ? [] : [one.id]);
+  const owner = await line(CEO_LABEL, () => ensureOrchestrator(client, existing, members, dryRun));
+  agents.push(owner);
+  const board = owner.action === "refused" || dryRun || owner.id === void 0 ? null : await client.board.create(owner.id);
+  const before = board === null ? [] : await listAll(client.config, `/v1/boards/${board.id}/cards`, BoardCardSchema, skipped);
+  const known = new Set(before.map((card) => card.id));
+  const ids = /* @__PURE__ */ new Map();
+  for (const task of inDependencyOrder(config.tasks)) {
+    into.push(
+      await line(task.key, async () => {
+        if (owner.action === "refused") return { name: task.key, action: "refused", reason: `board owner "${owner.name}" was refused: ${owner.reason}` };
+        const assignee = task.assignee;
+        if (assignee !== void 0 && !agents.some((one) => one.name === assignee && one.action !== "refused")) {
+          return { name: task.key, action: "refused", reason: `assignee "${assignee}" was not provisioned in this run` };
+        }
+        if (board === null) return { name: task.key, action: "created" };
+        const blockers = task.blocked_by ?? [];
+        const unmet = blockers.find((key) => !ids.has(key));
+        if (unmet !== void 0) return { name: task.key, action: "refused", reason: `blocked_by "${unmet}" was not seeded in this run` };
+        const card = await client.board.cards.create(board.id, {
+          key: `${config.name}:${task.key}`,
+          title: task.title,
+          body: task.body,
+          assignee,
+          blocked_by: blockers.map((key) => ids.get(key))
+        });
+        ids.set(task.key, card.id);
+        return {
+          name: task.key,
+          action: known.has(card.id) ? "unchanged" : "created",
+          id: card.id,
+          title: task.title,
+          ...assignee === void 0 ? {} : { assignee }
+        };
+      })
+    );
+  }
+}
+
 // src/vaults.ts
 async function upsertVault(client, decl, existing, identityIds, dryRun) {
   const identityId = decl.identity === void 0 ? void 0 : identityIds.get(decl.identity);
@@ -3737,7 +4146,7 @@ async function up(config, client, opts = {}) {
   const dir = opts.dir ?? process.cwd();
   const ids = { apps: /* @__PURE__ */ new Map(), identities: /* @__PURE__ */ new Map() };
   const taken = selectCrew(config, opts.select);
-  const report2 = { dry_run: dryRun, ...applied(config), skills: [], identities: [], vaults: [], apps: [], agents: [], schedules: [], intake: [], skipped: [], deselected: taken.deselected };
+  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 hosted = opts.trees !== void 0;
   for (const decl of config.skills) {
@@ -3796,11 +4205,15 @@ async function up(config, client, opts = {}) {
             platform
           },
           ids.apps
-        )
+        ),
+        // The app's id is recorded the moment it exists — before its secrets and deploy — so a
+        // failure in that upload reports `refused` naming the created app, not one the operator
+        // cannot find. A pre-create refusal (an unset `from_env`, a missing tree) has set nothing.
+        () => ids.apps.get(decl.name)
       )
     )
   );
-  const existing = taken.agents.length > 0 || config.removed.agents.length > 0 || config.kept.agents.length > 0 ? await listAll(client.config, "/v1/agents", AgentSchema, report2.skipped) : [];
+  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 crew = await eachInFlight(taken.agents, async (decl) => {
@@ -3827,6 +4240,7 @@ async function up(config, client, opts = {}) {
     if (hasRoster(decl.multiagent)) await patchRoster(client, decl, decl.multiagent, existing, agentIds, dryRun, report2.agents);
   }
   reportKept(config, existing, report2.agents);
+  if (config.tasks.length > 0) await seedTasks(client, config, existing, report2.agents, dryRun, report2.tasks, report2.skipped);
   await applyRemoved(client, config.removed, { agents: existing, vaults }, owner, report2);
   if (briefed.length > 0 && !dryRun) {
     const serving = taken.apps.flatMap((decl) => {