@usenaive-sdk/blueprints 0.5.0 → 0.6.0

package/dist/index.js

@@ -788,7 +788,11 @@ var SessionSchema = z6.object({
 var SendMessageSchema = z6.object({
   message: z6.string(),
   interrupt: z6.boolean().optional(),
+  queue: z6.boolean().optional(),
   idempotency_key: z6.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 = z6.object({
   session_id: z6.string(),
@@ -892,11 +896,16 @@ var BoardCardSchema = z8.object({
   object: z8.literal("board_card"),
   board_id: idOf("brd"),
   title: z8.string().min(1),
+  /** The brief — what was asked. */
   body: z8.string(),
+  /** What the holder wrote back; a `done` carries one. */
+  note: z8.string().nullable(),
   status: BoardStatusSchema,
   assignee: z8.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")),
+  woken_session_id: idOf("ses").nullable(),
+  reported_status: BoardStatusSchema.nullable(),
   created_at: Timestamp,
   updated_at: Timestamp
 });
@@ -1337,6 +1346,8 @@ var BlueprintReportSchema = z14.object({
   agents: z14.array(ResourceReportSchema),
   schedules: z14.array(ResourceReportSchema),
   intake: z14.array(ResourceReportSchema),
+  /** One line per declared task (§31.11), `id` the card's `crd_`. Defaulted so older rows parse. */
+  tasks: z14.array(ResourceReportSchema).default([]),
   skipped: z14.array(z14.string()),
   deselected: z14.array(z14.string()).default([])
 });
@@ -1426,202 +1437,221 @@ var ProjectContextSchema = z14.object({
 });
 
 // ../core/src/schema/blueprint.ts
+import { z as z16 } from "zod";
+
+// ../core/src/schema/social.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(),
+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 = z15.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 = z15.enum(SOCIAL_PLATFORMS);
+var SocialTextPlatformSchema = z15.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 = z15.object({
+  id: z15.string().min(1),
+  object: z15.literal("social_account"),
+  identity_id: idOf("idn"),
+  platform: SocialPlatformSchema,
+  username: z15.string().nullable(),
+  display_name: z15.string().nullable(),
+  avatar_url: z15.url().nullable(),
+  connected_at: Timestamp.nullable()
+});
+var SocialPostStatusSchema = z15.enum([
+  "draft",
+  "scheduled",
+  "processing",
+  "posted",
+  "failed",
+  "deleted"
+]);
+var SocialPostSchema = z15.object({
+  id: z15.string().min(1),
+  object: z15.literal("social_post"),
+  identity_id: idOf("idn"),
+  title: z15.string(),
+  platforms: z15.array(SocialPlatformSchema),
+  status: SocialPostStatusSchema,
+  scheduled_at: Timestamp.nullable(),
+  posted_at: Timestamp.nullable(),
+  error: z15.string().nullable()
+});
+var SocialUploadSchema = z15.object({
+  id: z15.string().min(1),
+  object: z15.literal("social_upload"),
+  identity_id: idOf("idn"),
+  type: z15.enum(["image", "video", "document"]),
+  url: z15.url().nullable()
+});
+var SocialAnalyticsSchema = z15.object({
+  object: z15.literal("social_analytics"),
+  identity_id: idOf("idn"),
+  resource_id: z15.string().min(1),
+  platform: SocialPlatformSchema.nullable(),
+  data: z15.unknown()
+});
+var SocialCommentSchema = z15.object({
+  id: z15.string().min(1),
+  object: z15.literal("social_comment"),
+  identity_id: idOf("idn"),
+  post_id: z15.string().min(1),
+  platforms: z15.array(SocialPlatformSchema),
+  status: SocialPostStatusSchema,
+  posted_at: Timestamp.nullable(),
+  data: z15.unknown()
+});
+
+// ../core/src/schema/blueprint.ts
+var BlueprintScheduleSchema = z16.object({
+  agent: z16.string().min(1),
+  cron: z16.string().min(1),
+  timezone: z16.string().nullable(),
   /** The message each fire opens its session with — the sentence worth printing. */
-  input: z15.string().min(1),
+  input: z16.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 = z16.object({
+  name: z16.string().min(1),
+  description: z16.string().nullable(),
+  model: z16.string().min(1),
+  briefed: z16.boolean(),
+  intake: z16.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: z16.string().min(1).optional(),
+  skills: z16.array(SkillRefSchema).optional(),
+  tools: z16.array(z16.string().min(1)).optional(),
+  required: z16.boolean().optional()
 });
-var BlueprintAppSchema = z15.object({
-  name: z15.string().min(1),
+var BlueprintAppSchema = z16.object({
+  name: z16.string().min(1),
   type: AppTypeSchema,
-  description: z15.string().nullable(),
-  mcp: z15.string().nullable().optional(),
-  tools: z15.array(z15.string().min(1)).optional(),
+  description: z16.string().nullable(),
+  mcp: z16.string().nullable().optional(),
+  tools: z16.array(z16.string().min(1)).optional(),
   /** Whether an install may deselect it (§31.2). Optional: the rollout argument above. */
-  required: z15.boolean().optional()
+  required: z16.boolean().optional()
+});
+var BlueprintIdentityConnectionsSchema = z16.object({
+  social: z16.object({
+    from: z16.string().min(1),
+    map: z16.record(z16.string().min(1), SocialPlatformSchema)
+  }).optional()
 });
-var ContentHashSchema = z15.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
-var BlueprintTreeSchema = z15.object({
+var BlueprintIdentitySchema = z16.object({
+  name: z16.string().min(1),
+  description: z16.string().nullable(),
+  connections: BlueprintIdentityConnectionsSchema.optional()
+});
+var ContentHashSchema = z16.string().regex(/^[0-9a-f]{64}$/, "a lowercase sha-256 hex digest");
+var BlueprintTreeSchema = z16.object({
   /** `apps[].name` in the declaration — the same name §31.5 prints and the install ensures by. */
-  app: z15.string().min(1),
+  app: z16.string().min(1),
   content_hash: ContentHashSchema
 });
-var BlueprintArtifactSchema = z15.object({
+var BlueprintArtifactSchema = z16.object({
   id: idOf("bpa"),
-  object: z15.literal("blueprint_artifact"),
+  object: z16.literal("blueprint_artifact"),
   /** The machine — its repository, screens and `/api/*`. */
-  blueprint: z15.string().min(1),
+  blueprint: z16.string().min(1),
   /** Which of that blueprint's templates provides the crew. */
-  template: z15.string().min(1),
+  template: z16.string().min(1),
   /** The blueprint repository's own released version. Stored, never parsed (ADR-0401). */
-  version: z15.string().min(1),
+  version: z16.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: z16.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: z16.array(QuestionFieldSchema),
+  schedules: z16.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: z16.array(BlueprintCrewSchema),
+  apps: z16.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: z16.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: z16.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: z16.number().int().positive().nullish(),
+  creator_name: z16.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 z17 } from "zod";
+var VaultCredentialKindSchema = z17.enum(["env_var", "static_bearer", "mcp_oauth"]);
+var VaultSchema = z17.object({
   id: idOf("vlt"),
-  object: z16.literal("vault"),
+  object: z17.literal("vault"),
   identity_id: idOf("idn").nullable(),
-  display_name: z16.string().min(1).max(128),
-  credential_count: z16.number().int().nonnegative(),
+  display_name: z17.string().min(1).max(128),
+  credential_count: z17.number().int().nonnegative(),
   created_at: Timestamp
 });
-var VaultCredentialSchema = z16.object({
+var VaultCredentialSchema = z17.object({
   id: idOf("vcr"),
-  object: z16.literal("vault_credential"),
+  object: z17.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: z17.string().min(1).max(128),
   /** The exact destination host an `env_var` credential is bound to. Never a wildcard. */
-  host: z16.string().nullable(),
+  host: z17.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: z17.url().nullable(),
+  placeholder_ref: z17.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 MAX_HANDOFF_TARGETS = 6;
 var HandoffRequestSchema = z18.object({
   agent: z18.string().min(1),
   message: z18.string().min(1),
@@ -1634,12 +1664,42 @@ var HandoffSchema = z18.object({
   status: z18.enum(["queued", "already_running"]),
   handoff_key: z18.string().nullable()
 });
+var SessionHandoffRequestSchema = z18.object({
+  agents: z18.array(z18.string().min(1)).min(1).max(MAX_HANDOFF_TARGETS),
+  message: z18.string().min(1),
+  handoff_key: z18.string().min(1).max(128).optional(),
+  budget_micro_usd: z18.number().int().positive().optional()
+});
+var HandoffRefusalSchema = z18.object({
+  object: z18.literal("handoff_refusal"),
+  agent: z18.string(),
+  code: z18.string(),
+  message: z18.string()
+});
+var HandoffBatchSchema = z18.object({
+  object: z18.literal("handoff_batch"),
+  handoffs: z18.array(HandoffSchema.extend({ agent_id: idOf("agt") })),
+  refusals: z18.array(HandoffRefusalSchema)
+});
 var SessionHandoffSchema = z18.object({
   from_session: idOf("ses"),
   from_agent: idOf("agt"),
   key: z18.string().nullable(),
   depth: z18.number().int().positive()
 });
+var ChannelBriefSchema = z18.object({
+  root_session_id: idOf("ses"),
+  name: z18.string().min(1),
+  members: z18.array(z18.string().min(1))
+});
+var ChannelPostRequestSchema = z18.object({
+  message: z18.string().min(1).max(2e4)
+});
+var ChannelPostSchema = z18.object({
+  object: z18.literal("channel_post"),
+  root_session_id: idOf("ses"),
+  queued: z18.boolean()
+});
 
 // ../core/src/schema/media.ts
 import { z as z19 } from "zod";
@@ -2675,6 +2735,7 @@ var WalletDeclSchema = CreateWalletSchema.or(
 );
 var CardDeclSchema = IssueCardSchema;
 var IdentityDeclSchema = IdentitySchema.pick({ name: true, description: true }).partial({ description: true }).extend({
+  connections: BlueprintIdentityConnectionsSchema.optional(),
   legal: z28.array(LegalDeclSchema).optional(),
   wallet: WalletDeclSchema.optional(),
   cards: z28.array(CardDeclSchema).optional()
@@ -2687,6 +2748,13 @@ var RemovedSchema = z28.object({
   vaults: z28.array(z28.string().min(1)).default([])
 });
 var KeptSchema = z28.object({ agents: z28.array(z28.string().min(1)).default([]) });
+var TaskDeclSchema = z28.object({
+  key: z28.string().min(1),
+  title: z28.string().min(1).max(200),
+  body: z28.string().max(8192).optional(),
+  assignee: z28.string().min(1).optional(),
+  blocked_by: z28.array(z28.string().min(1)).optional()
+});
 var ProjectSchema = z28.object({
   name: z28.string().min(1),
   /** The machine this project runs: its repo, its screens, its `/api/*` (`template.ts`). */
@@ -2717,6 +2785,8 @@ var ProjectSchema = z28.object({
    * 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(),
+  /** The crew's first work, as cards on the organization's board rather than N private intakes (§31.11). */
+  tasks: z28.array(TaskDeclSchema).default([]),
   removed: RemovedSchema.default({ apps: [], agents: [], skills: [], identities: [], vaults: [] }),
   kept: KeptSchema.default({ agents: [] })
 });
@@ -2732,6 +2802,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);
@@ -2779,6 +2863,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 +2935,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) {
@@ -3527,6 +3640,75 @@ 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 };
+      })
+    );
+  }
+}
+
 // 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 +3919,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) {
@@ -3800,7 +3982,7 @@ async function up(config, client, opts = {}) {
       )
     )
   );
-  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 +4009,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) => {