@usenaive-sdk/blueprints 0.1.0

package/dist/index.js

@@ -0,0 +1,1674 @@
+// ../core/src/id.ts
+var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+var SUFFIX_LENGTH = 26;
+var SUFFIX_PATTERN = new RegExp(`^[${ALPHABET}]{${SUFFIX_LENGTH},}$`);
+function isId(prefix, value) {
+  const head = `${prefix}_`;
+  if (!value.startsWith(head)) return false;
+  return SUFFIX_PATTERN.test(value.slice(head.length).toLowerCase());
+}
+
+// ../core/src/session-token.ts
+var SESSION_TTL_SECONDS = 30 * 24 * 60 * 60;
+var encoder = new TextEncoder();
+
+// ../core/src/schema/audit-actions.ts
+var AUDIT_ACTIONS_SHIPPED = [
+  "agent.updated",
+  "agent.rolled_back",
+  // deprecated alias of `agent.rollback`; kept so historic rows still validate
+  "api_key.created",
+  "api_key.rotated",
+  "api_key.revoked",
+  "member.role_changed",
+  "member.removed",
+  "policy.denied",
+  "credits.topped_up",
+  "webhook.secret_rotated",
+  "session.interrupted"
+];
+var AUDIT_ACTIONS_P1 = [
+  "agent.created",
+  "agent.deleted",
+  "agent.rollback",
+  "computer.created",
+  "computer.deleted",
+  "computer.paused",
+  "computer.resumed",
+  "computer.snapshot_created",
+  "deployment.created",
+  "deployment.updated",
+  "deployment.deleted",
+  "deployment.paused",
+  "deployment.resumed",
+  "deployment.run",
+  "file.created",
+  "file.published",
+  "file.deleted",
+  "member.invited",
+  "org.updated",
+  "subscription.updated",
+  "subscription.canceled",
+  "session.budget_updated",
+  "session.cancelled",
+  "skill.created",
+  "skill.version_created",
+  "skill.deleted",
+  "webhook.created",
+  "webhook.updated",
+  "webhook.deleted"
+];
+var AUDIT_ACTIONS_P2 = [
+  "identity.created",
+  "identity.updated",
+  "identity.deleted",
+  "identity.granted",
+  "identity.revoked",
+  "vault.created",
+  "vault.deleted",
+  "credential.sealed",
+  "credential.destroyed",
+  "connection.created",
+  "connection.disconnected",
+  "connection.auth_config_created",
+  "connection.auth_config_deleted",
+  "domain.created",
+  "domain.verified",
+  "domain.deleted",
+  "email.created",
+  "email.deleted",
+  "phone.created",
+  "phone.deleted",
+  "social.activated",
+  "social.post_created",
+  "social.post_deleted"
+];
+var AUDIT_ACTIONS_P3 = [
+  "app.created",
+  "app.updated",
+  "app.deleted",
+  "app.deployed",
+  "app.secret_set",
+  "app.secret_deleted",
+  "app.domain_connected",
+  "app.domain_disconnected",
+  "app.db_queried"
+];
+var AUDIT_ACTIONS = [
+  ...AUDIT_ACTIONS_SHIPPED,
+  ...AUDIT_ACTIONS_P1,
+  ...AUDIT_ACTIONS_P2,
+  ...AUDIT_ACTIONS_P3
+];
+
+// ../core/src/schema/common.ts
+import { z } from "zod";
+var idOf = (prefix) => z.string().refine((value) => isId(prefix, value), { error: `expected a ${prefix}_ id` });
+var Timestamp = z.iso.datetime({ offset: true });
+var MicroUsdField = z.number().int();
+var Metadata = z.record(z.string(), z.unknown());
+var JsonSchemaDocument = z.record(z.string(), z.unknown()).refine((schema) => schema.type === "object", {
+  error: 'an output schema must be a JSON Schema with "type": "object"'
+}).refine(
+  (schema) => typeof schema.properties === "object" && schema.properties !== null && Object.keys(schema.properties).length > 0,
+  { error: "an output schema must declare at least one property" }
+);
+var WindowSchema = z.enum(["immediate", "priority", "loose"]);
+var TOKEN_TIERS = ["input", "cache_write", "cache_read", "output", "reasoning"];
+var TokenTierSchema = z.enum(TOKEN_TIERS);
+var TOOL_TIERS = ["search", "media", "social"];
+var LINE_ITEM_TIERS = [...TOKEN_TIERS, "computer", ...TOOL_TIERS];
+var LineItemTierSchema = z.enum(LINE_ITEM_TIERS);
+var TokenUsageSchema = z.object({
+  input: z.number().int().nonnegative(),
+  cache_write: z.number().int().nonnegative(),
+  cache_read: z.number().int().nonnegative(),
+  output: z.number().int().nonnegative(),
+  reasoning: z.number().int().nonnegative()
+});
+var PrincipalSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("user"), id: idOf("usr") }),
+  z.object({ type: z.literal("key"), id: idOf("key") }),
+  z.object({ type: z.literal("system"), id: z.string().min(1) })
+]);
+var AuditActionSchema = z.enum(AUDIT_ACTIONS);
+
+// ../core/src/schema/harness.ts
+import { z as z2 } from "zod";
+var HARNESS_IDS = ["pi", "claude_code", "vetta", "hermes"];
+var HarnessIdSchema = z2.enum(HARNESS_IDS);
+
+// ../core/src/schema/agent.ts
+import { z as z3 } from "zod";
+var ToolPermissionSchema = z3.enum(["allow", "ask", "deny"]);
+var ToolConfigSchema = z3.object({
+  enabled: z3.boolean(),
+  permission: ToolPermissionSchema,
+  config: z3.record(z3.string(), z3.unknown()).optional()
+});
+var ToolsetSchema = z3.object({
+  default_config: z3.object({ permission: ToolPermissionSchema }),
+  configs: z3.record(z3.string(), ToolConfigSchema)
+});
+var BudgetSchema = z3.object({
+  cap_micro_usd: MicroUsdField.nonnegative(),
+  max_task_micro_usd: MicroUsdField.nonnegative(),
+  period: z3.enum(["day", "week", "month"])
+});
+var SkillRefSchema = z3.string().regex(/^[a-z0-9][a-z0-9-]*(@\d+)?$/, {
+  error: "expected `slug` or `slug@N`"
+});
+var McpServerSchema = z3.object({
+  name: z3.string(),
+  url: z3.url(),
+  headers: z3.record(z3.string(), z3.string()).optional()
+});
+var RosterEntrySchema = z3.union([
+  idOf("agt").transform((id) => ({ type: "agent", id })),
+  z3.object({
+    type: z3.literal("agent"),
+    id: idOf("agt"),
+    version: z3.number().int().positive().optional()
+  }),
+  z3.object({ type: z3.literal("self") }),
+  z3.object({ type: z3.literal("advisor"), model: z3.string().min(1) })
+]);
+var SINGLETON_ENTRIES = ["self", "advisor"];
+var MultiagentSchema = z3.object({
+  type: z3.literal("coordinator"),
+  agents: z3.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: z3.boolean().optional()
+});
+var MultiagentField = z3.union([z3.boolean(), MultiagentSchema, z3.null()]);
+var agentConfigShape = {
+  model: z3.string(),
+  window: WindowSchema,
+  system: z3.string(),
+  tools: ToolsetSchema,
+  mcp_servers: z3.array(McpServerSchema),
+  skills: z3.array(SkillRefSchema),
+  multiagent: MultiagentField,
+  budget: BudgetSchema,
+  output_schema: JsonSchemaDocument.nullable(),
+  structured_output_required: z3.boolean(),
+  description: z3.string().nullable(),
+  metadata: Metadata
+};
+var AgentVersionSchema = z3.object({
+  version: z3.number().int().positive(),
+  created_at: Timestamp,
+  created_by: PrincipalSchema,
+  ...agentConfigShape
+});
+var AgentSchema = z3.object({
+  id: idOf("agt"),
+  object: z3.literal("agent"),
+  name: z3.string(),
+  /** The agent loop this agent runs (§19). Chosen at create; the catalog lives in `harness.ts`. */
+  harness: HarnessIdSchema,
+  current_version: z3.number().int().positive(),
+  created_at: Timestamp,
+  ...agentConfigShape
+});
+
+// ../core/src/schema/session.ts
+import { z as z4 } from "zod";
+var SessionStatusSchema = z4.enum([
+  "queued",
+  "running",
+  "idle",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var StopReasonSchema = z4.enum([
+  "end_turn",
+  "awaiting_input",
+  "awaiting_approval",
+  "budget_paused",
+  "interrupted",
+  "error",
+  "max_iterations",
+  /** A turn produced no message and no tool call — honest failure, never `end_turn` (entry 4). */
+  "context_exhausted",
+  /**
+   * A coordinator yielded because every delegated child it is waiting on is still running (§28).
+   * Distinct from `awaiting_input`: nobody is being asked for anything, so no human can unblock it —
+   * the child's completion does. Reporting `idle`/`end_turn` here would claim the task was finished.
+   */
+  "awaiting_delegation"
+]);
+var ThreadRoleSchema = z4.enum(["coordinator", "member"]);
+var MessageSchema = z4.object({
+  role: z4.enum(["system", "user", "assistant", "tool"]),
+  content: z4.string(),
+  tool_call_id: z4.string().optional()
+});
+var ToolResultSchema = z4.object({
+  output: z4.unknown(),
+  is_error: z4.boolean().optional(),
+  content: z4.string().optional()
+});
+var PendingActionSchema = z4.object({
+  tool_call_id: z4.string(),
+  name: z4.string(),
+  args: z4.record(z4.string(), z4.unknown())
+});
+var SessionSchema = z4.object({
+  id: idOf("ses"),
+  object: z4.literal("session"),
+  agent_id: idOf("agt"),
+  agent_version: z4.number().int().positive(),
+  deployment_id: idOf("dep").nullable(),
+  /**
+   * The persona this session acts as (`canonical-spec §22`). Chosen per task from the personas the
+   * agent holds a grant to, and `null` when the caller named none — an agent with several
+   * identities is not silently given one.
+   */
+  identity_id: idOf("idn").nullable(),
+  /**
+   * The sandbox this session provisioned, or `null` when its toolset needs none. It is a real
+   * `Computer`: it lists under `GET /v1/computers`, takes `exec`/`snapshot`, and is destroyed when
+   * the session can no longer run a turn (ADR-0160).
+   */
+  computer_id: idOf("cmp").nullable(),
+  /**
+   * The delegation lineage (§28). `parent_session_id` is the thread that delegated this one and
+   * `root_session_id` the coordinator at the top of the tree; both `null` on a session a customer
+   * started. A child is addressable on its own but is excluded from the default `GET /v1/sessions`
+   * listing, so a team of ten does not bury the ten tasks the customer actually asked for.
+   */
+  parent_session_id: idOf("ses").nullable(),
+  root_session_id: idOf("ses").nullable(),
+  thread_role: ThreadRoleSchema.nullable(),
+  status: SessionStatusSchema,
+  stop_reason: StopReasonSchema.nullable(),
+  window: WindowSchema,
+  budget_micro_usd: MicroUsdField.nonnegative(),
+  consumed_micro_usd: MicroUsdField.nonnegative(),
+  token_usage: TokenUsageSchema,
+  pending_actions: z4.array(PendingActionSchema),
+  output_schema: JsonSchemaDocument.nullable(),
+  structured_output: z4.record(z4.string(), z4.unknown()).nullable(),
+  last_seq: z4.number().int().nonnegative(),
+  metadata: Metadata,
+  started_at: Timestamp.nullable(),
+  ended_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var SendMessageSchema = z4.object({
+  message: z4.string(),
+  interrupt: z4.boolean().optional(),
+  idempotency_key: z4.string().optional()
+});
+var SendAcceptedSchema = z4.object({
+  session_id: z4.string(),
+  status: SessionStatusSchema,
+  accepted_seq: z4.number().int().nonnegative()
+});
+var ToolConfirmationSchema = z4.object({
+  tool_call_id: z4.string(),
+  decision: z4.enum(["allow", "deny"]),
+  reason: z4.string().optional()
+});
+
+// ../core/src/schema/event.ts
+import { z as z5 } from "zod";
+var EventTypeSchema = z5.enum([
+  "message.delta",
+  "message.completed",
+  "tool.started",
+  "tool.completed",
+  "tool.confirm",
+  "session.running",
+  "session.usage",
+  "session.idle",
+  "budget.exceeded",
+  "span.model_request.start",
+  "span.model_request.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
+   * no column, so one reader of `{session_id, seq}` still sees every event in one order.
+   */
+  "thread.created",
+  "thread.running",
+  "thread.idle",
+  "thread.terminated"
+]);
+var EventSchema = z5.object({
+  id: idOf("evt"),
+  seq: z5.number().int().positive(),
+  type: EventTypeSchema,
+  session_id: idOf("ses"),
+  data: z5.record(z5.string(), z5.unknown()),
+  created_at: Timestamp
+});
+var ThreadEventDataSchema = z5.looseObject({ thread_id: idOf("ses") });
+var SessionUsageDataSchema = z5.object({
+  token_usage: TokenUsageSchema,
+  consumed_micro_usd: MicroUsdField.nonnegative(),
+  active_seconds: z5.number().nonnegative(),
+  tool_calls: z5.number().int().nonnegative()
+});
+
+// ../core/src/schema/board.ts
+import { z as z6 } from "zod";
+var BOARD_STATUSES = ["todo", "doing", "blocked", "done"];
+var BoardStatusSchema = z6.enum(BOARD_STATUSES);
+var BoardCountsSchema = z6.object({
+  todo: z6.number().int().nonnegative(),
+  doing: z6.number().int().nonnegative(),
+  blocked: z6.number().int().nonnegative(),
+  done: z6.number().int().nonnegative()
+});
+var BoardSchema = z6.object({
+  id: idOf("brd"),
+  object: z6.literal("board"),
+  agent_id: idOf("agt"),
+  cards: BoardCountsSchema,
+  created_at: Timestamp
+});
+var BoardCardSchema = z6.object({
+  id: idOf("crd"),
+  object: z6.literal("board_card"),
+  board_id: idOf("brd"),
+  title: z6.string().min(1),
+  body: z6.string(),
+  status: BoardStatusSchema,
+  assignee: z6.string().nullable(),
+  /** The cards this one waits on. A `blocked` card with an empty list is stuck on the world. */
+  blocked_by: z6.array(idOf("crd")),
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+var BoardCommentSchema = z6.object({
+  id: idOf("bcm"),
+  object: z6.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
+   * comment carries the `ses_` id of the thread that wrote it; a person's carries their `usr_` or
+   * `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: z6.string(),
+  body: z6.string(),
+  created_at: Timestamp
+});
+
+// ../core/src/schema/identity.ts
+import { z as z7 } from "zod";
+var IDENTITY_NAME_MAX = 128;
+var IDENTITY_DESCRIPTION_MAX = 1024;
+var IdentitySchema = z7.object({
+  id: idOf("idn"),
+  object: z7.literal("identity"),
+  /** Human-facing persona name. Surfaced to the model so it acts in character. */
+  name: z7.string().min(1).max(IDENTITY_NAME_MAX),
+  /** What the persona is for. The model reads it to choose tone, scope and endpoint. */
+  description: z7.string().max(IDENTITY_DESCRIPTION_MAX).nullable(),
+  /** Inbox addresses (`localpart@domain`) this identity owns. */
+  emails: z7.array(z7.string()),
+  /** Provisioned numbers in E.164. */
+  phones: z7.array(z7.string()),
+  /** Verified web domains reachable through this identity's inboxes. */
+  domains: z7.array(z7.string()),
+  /** `conn_` ids of authorized third-party connections. */
+  connections: z7.array(z7.string()),
+  metadata: Metadata,
+  created_at: Timestamp,
+  updated_at: Timestamp
+});
+
+// ../core/src/schema/resource.ts
+import { z as z8 } from "zod";
+var ComputerStatusSchema = z8.enum(["creating", "running", "paused", "failed", "destroyed"]);
+var VolumeSchema = z8.object({
+  id: idOf("vol"),
+  size_gb: z8.number().int().positive(),
+  mount_path: z8.string()
+});
+var ComputerSchema = z8.object({
+  id: idOf("cmp"),
+  object: z8.literal("computer"),
+  name: z8.string(),
+  vcpu: z8.number().int().positive(),
+  memory_mb: z8.number().int().positive(),
+  disk_gb: z8.number().int().positive(),
+  status: ComputerStatusSchema,
+  browser: z8.object({ allowed_domains: z8.array(z8.string()) }).nullable(),
+  volume: VolumeSchema.nullable(),
+  snapshot_id: idOf("snp").nullable(),
+  created_at: Timestamp
+});
+var SnapshotSchema = z8.object({
+  snapshot_id: idOf("snp"),
+  computer_id: idOf("cmp"),
+  created_at: Timestamp
+});
+var SkillSchema = z8.object({
+  id: idOf("skl"),
+  object: z8.literal("skill"),
+  name: z8.string(),
+  description: z8.string().nullable(),
+  latest_version: z8.number().int().positive(),
+  created_at: Timestamp
+});
+var ResolvedSkillRefSchema = z8.object({
+  /** The reference exactly as the agent version wrote it: `slug` or `slug@N`. */
+  ref: z8.string().min(1),
+  slug: z8.string().min(1),
+  version: z8.number().int().positive(),
+  description: z8.string(),
+  storage_key: z8.string().min(1)
+});
+var SkillVersionSchema = z8.object({
+  version: z8.number().int().positive(),
+  sha256: z8.string().regex(/^[0-9a-f]{64}$/),
+  size_bytes: z8.number().int().nonnegative(),
+  created_at: Timestamp
+});
+var FileSchema = z8.object({
+  id: idOf("fil"),
+  object: z8.literal("file"),
+  name: z8.string(),
+  content_type: z8.string(),
+  size_bytes: z8.number().int().nonnegative(),
+  scope: z8.enum(["session", "published"]),
+  session_id: idOf("ses").nullable(),
+  sha256: z8.string().regex(/^[0-9a-f]{64}$/),
+  created_at: Timestamp
+});
+var ScheduleStatusSchema = z8.enum(["scheduled", "paused", "unscheduled"]);
+var DeploymentSchema = z8.object({
+  id: idOf("dep"),
+  object: z8.literal("deployment"),
+  agent_id: idOf("agt"),
+  /** A pin. `null` tracks the agent's `current_version` on every fire (§12). */
+  agent_version: z8.number().int().positive().nullable(),
+  cron: z8.string(),
+  /** IANA zone the `cron` is read in. "0 9 * * 1" means 09:00 *here*, across DST (ADR-0074). */
+  timezone: z8.string(),
+  input_template: z8.string(),
+  budget_micro_usd: MicroUsdField.nonnegative(),
+  window: WindowSchema,
+  /**
+   * URL POSTed with the `session.idle` envelope when a fire goes idle; `null` pushes nothing.
+   *
+   * `https` for the same reason `POST /v1/webhooks` requires it — setting this materialises one of
+   * 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: z8.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: z8.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 = z8.object({
+  id: idOf("run"),
+  session_id: idOf("ses"),
+  status: SessionStatusSchema,
+  started_at: Timestamp.nullable()
+});
+
+// ../core/src/schema/org.ts
+import { z as z9 } from "zod";
+var OrganizationSchema = z9.object({
+  id: idOf("org"),
+  object: z9.literal("organization"),
+  name: z9.string(),
+  balance_micro_usd: MicroUsdField,
+  created_at: Timestamp
+});
+var RoleSchema = z9.enum(["owner", "admin", "member"]);
+var MemberSchema = z9.object({
+  id: z9.string(),
+  object: z9.literal("member"),
+  email: z9.email(),
+  role: RoleSchema,
+  invited_by: z9.string().nullable(),
+  created_at: Timestamp
+});
+var SCOPES = [
+  "agents:read",
+  "agents:write",
+  "sessions:read",
+  "sessions:write",
+  /**
+   * THE MODEL DOOR AND NOTHING ELSE. `/v1/proxy/*` used to take `sessions:write`, which also opens
+   * session create and cancel — so a credential handed to a customer's micro-VM, if it leaked, could
+   * start sessions for the whole organization. This scope buys exactly one capability, so a sandbox
+   * token can be minted with it alone.
+   *
+   * The proxy routes accept EITHER this or `sessions:write`: narrowing an already-published route
+   * would break every key that reaches it today (§17).
+   */
+  "proxy:write",
+  "computers:write",
+  "files:read",
+  "files:write",
+  "billing:read",
+  "billing:write",
+  "webhooks:*",
+  "audit:read",
+  "admin"
+];
+var ScopeSchema = z9.enum(SCOPES);
+var ApiKeySchema = z9.object({
+  id: idOf("key"),
+  object: z9.literal("api_key"),
+  name: z9.string(),
+  prefix: z9.string(),
+  scopes: z9.array(ScopeSchema),
+  created_by: PrincipalSchema,
+  last_used_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var LedgerEntrySchema = z9.object({
+  id: idOf("led"),
+  type: z9.enum(["debit", "credit"]),
+  amount_micro_usd: MicroUsdField,
+  balance_after_micro_usd: MicroUsdField,
+  actor: PrincipalSchema,
+  session_id: idOf("ses").nullable(),
+  agent_id: idOf("agt").nullable(),
+  deployment_id: idOf("dep").nullable(),
+  line_items: z9.array(z9.object({ tier: LineItemTierSchema, amount_micro_usd: MicroUsdField })),
+  created_at: Timestamp
+});
+var TopupSchema = z9.object({
+  id: z9.string(),
+  object: z9.literal("topup"),
+  amount_micro_usd: MicroUsdField.positive(),
+  status: z9.enum(["pending", "requires_action", "succeeded", "failed"]),
+  action_url: z9.url().nullable(),
+  balance_after_micro_usd: MicroUsdField.nullable(),
+  created_at: Timestamp
+});
+var WebhookEndpointSchema = z9.object({
+  id: idOf("whk"),
+  object: z9.literal("webhook_endpoint"),
+  url: z9.url(),
+  events: z9.array(z9.string()),
+  enabled: z9.boolean(),
+  created_at: Timestamp
+});
+var WebhookDeliverySchema = z9.object({
+  id: idOf("whd"),
+  event_id: idOf("evt"),
+  event_type: z9.string(),
+  status: z9.enum(["pending", "succeeded", "failed"]),
+  attempts: z9.number().int().nonnegative(),
+  response_status: z9.number().int().nullable(),
+  response_snippet: z9.string().nullable(),
+  delivered_at: Timestamp.nullable(),
+  next_retry_at: Timestamp.nullable()
+});
+var AuditEntrySchema = z9.object({
+  id: idOf("aud"),
+  object: z9.literal("audit_entry"),
+  actor: PrincipalSchema,
+  action: AuditActionSchema,
+  resource_type: z9.string(),
+  resource_id: z9.string(),
+  request_id: z9.string(),
+  metadata: Metadata,
+  created_at: Timestamp
+});
+
+// ../core/src/schema/comms.ts
+import { z as z10 } from "zod";
+var DomainKindSchema = z10.enum(["system", "external", "purchased"]);
+var DomainStatusSchema = z10.enum(["pending_dns", "active", "failed"]);
+var DomainDnsStatusSchema = z10.enum(["pending_verification", "provisioned", "failed"]);
+var DomainInboundStatusSchema = z10.enum(["pending", "verified", "failed"]);
+var DomainAppConnectStatusSchema = z10.enum(["pending", "connected", "failed"]);
+var DnsRecordSchema = z10.object({
+  type: z10.enum(["TXT", "CNAME", "MX"]),
+  host: z10.string(),
+  value: z10.string(),
+  priority: z10.number().int().nullable(),
+  /** Vetta owns this record: `_dmarc`, DKIM, inbound MX. The agent may read it, never write it. */
+  managed: z10.boolean()
+});
+var DomainSchema = z10.object({
+  id: idOf("dom"),
+  object: z10.literal("domain"),
+  /** A domain belongs to the **organization**, not to one identity: two identities share one. */
+  name: z10.string(),
+  kind: DomainKindSchema,
+  status: DomainStatusSchema,
+  dns_status: DomainDnsStatusSchema,
+  inbound_status: DomainInboundStatusSchema,
+  app_connect_status: DomainAppConnectStatusSchema,
+  records: z10.array(DnsRecordSchema),
+  last_verified_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var EmailInboxSchema = z10.object({
+  id: idOf("eml"),
+  object: z10.literal("email_inbox"),
+  identity_id: idOf("idn"),
+  domain_id: idOf("dom"),
+  address: z10.string(),
+  localpart: z10.string(),
+  /** Inbound routing keys off this: mail to the address wakes exactly this agent. */
+  owning_agent_id: idOf("agt"),
+  status: z10.enum(["active", "disabled"]),
+  created_at: Timestamp
+});
+var PhoneTierSchema = z10.enum(["sole_prop", "standard"]);
+var BrandStatusSchema = z10.enum(["none", "pending_verification", "verified", "rejected"]);
+var CampaignStatusSchema = z10.enum(["none", "pending", "approved", "rejected"]);
+var PhoneNumberSchema = z10.object({
+  id: idOf("pho"),
+  object: z10.literal("phone_number"),
+  identity_id: idOf("idn"),
+  e164: z10.string(),
+  country: z10.string(),
+  capabilities: z10.object({
+    /** Live the moment the number is bought — inbound never waits on carrier registration. */
+    sms_inbound: z10.boolean(),
+    /** True **iff** `campaign_status === "approved"`. Nothing else may set it. */
+    sms_outbound: z10.boolean(),
+    /** Voice is not a P2 capability; the field exists so its absence is explicit. */
+    voice: z10.literal(false)
+  }),
+  tier: PhoneTierSchema,
+  brand_status: BrandStatusSchema,
+  campaign_status: CampaignStatusSchema,
+  provisioned_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+var InboundMessageSchema = z10.object({
+  id: idOf("inb"),
+  object: z10.literal("inbound_message"),
+  channel: z10.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: z10.string(),
+  from: z10.string(),
+  to: z10.string(),
+  subject: z10.string().nullable(),
+  text: z10.string(),
+  /** SPF/DKIM/DMARC for mail, carrier origin for SMS. Kept for the audit of why it was accepted. */
+  auth: z10.record(z10.string(), z10.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 z11 } from "zod";
+var AppTypeSchema = z11.enum(["frontend_only", "fullstack"]);
+var AppStatusSchema = z11.enum(["provisioning", "active", "error"]);
+var AppMcpPathSchema = z11.string().regex(/^\/\S*$/, "must be an absolute path beginning with /").max(128);
+var AppSchema = z11.object({
+  id: idOf("app"),
+  object: z11.literal("app"),
+  name: z11.string(),
+  description: z11.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: z11.string().nullable(),
+  status: AppStatusSchema,
+  /** The address the app answers on — platform hostname until a custom domain connects. */
+  url: z11.string().nullable(),
+  /** White-label words when `status` is `error`; never the provider's. */
+  error: z11.string().nullable(),
+  /** Where the app serves MCP, or `null`. The bearer token for it is a server column. */
+  mcp: AppMcpPathSchema.nullable(),
+  created_at: Timestamp
+});
+var AppDeploymentStatusSchema = z11.enum(["queued", "building", "ready", "error"]);
+var AppDeploymentSchema = z11.object({
+  id: idOf("apd"),
+  object: z11.literal("app_deployment"),
+  app_id: idOf("app"),
+  status: AppDeploymentStatusSchema,
+  url: z11.string().nullable(),
+  error: z11.string().nullable(),
+  /** The client's opaque digest of the files, echoed verbatim so it can skip an unchanged deploy. */
+  content_hash: z11.string().nullable(),
+  created_at: Timestamp
+});
+var AppSecretSchema = z11.object({
+  object: z11.literal("app_secret"),
+  name: z11.string(),
+  /** The client's opaque digest of the value, echoed verbatim so it can skip an unchanged write. */
+  value_hash: z11.string().nullable(),
+  created_at: Timestamp
+});
+var AppDomainStatusSchema = z11.enum(["pending", "connected", "failed"]);
+var AppDomainSchema = z11.object({
+  object: z11.literal("app_domain"),
+  app_id: idOf("app"),
+  domain_id: idOf("dom"),
+  domain: z11.string(),
+  status: AppDomainStatusSchema,
+  created_at: Timestamp
+});
+var ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
+var APP_NAME = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+
+// ../core/src/schema/vault.ts
+import { z as z12 } from "zod";
+var VaultCredentialKindSchema = z12.enum(["env_var", "static_bearer", "mcp_oauth"]);
+var VaultSchema = z12.object({
+  id: idOf("vlt"),
+  object: z12.literal("vault"),
+  identity_id: idOf("idn").nullable(),
+  display_name: z12.string().min(1).max(128),
+  credential_count: z12.number().int().nonnegative(),
+  created_at: Timestamp
+});
+var VaultCredentialSchema = z12.object({
+  id: idOf("vcr"),
+  object: z12.literal("vault_credential"),
+  vault_id: idOf("vlt"),
+  kind: VaultCredentialKindSchema,
+  /** For `env_var`, the environment variable name. For the MCP kinds, a display label. */
+  key: z12.string().min(1).max(128),
+  /** The exact destination host an `env_var` credential is bound to. Never a wildcard. */
+  host: z12.string().nullable(),
+  /** The exact MCP server URL an `mcp_*` token is matched to. */
+  mcp_server_url: z12.url().nullable(),
+  placeholder_ref: z12.string(),
+  expires_at: Timestamp.nullable(),
+  last_injected_at: Timestamp.nullable(),
+  created_at: Timestamp
+});
+
+// ../core/src/schema/social.ts
+import { z as z13 } 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 SocialPlatformSchema = z13.enum(SOCIAL_PLATFORMS);
+var SocialTextPlatformSchema = z13.enum(SOCIAL_TEXT_PLATFORMS);
+var SocialAccountSchema = z13.object({
+  id: z13.string().min(1),
+  object: z13.literal("social_account"),
+  identity_id: idOf("idn"),
+  platform: SocialPlatformSchema,
+  username: z13.string().nullable(),
+  display_name: z13.string().nullable(),
+  avatar_url: z13.url().nullable(),
+  connected_at: Timestamp.nullable()
+});
+var SocialPostStatusSchema = z13.enum([
+  "draft",
+  "scheduled",
+  "processing",
+  "posted",
+  "failed",
+  "deleted"
+]);
+var SocialPostSchema = z13.object({
+  id: z13.string().min(1),
+  object: z13.literal("social_post"),
+  identity_id: idOf("idn"),
+  title: z13.string(),
+  platforms: z13.array(SocialTextPlatformSchema),
+  status: SocialPostStatusSchema,
+  scheduled_at: Timestamp.nullable(),
+  posted_at: Timestamp.nullable(),
+  error: z13.string().nullable()
+});
+var SocialUploadSchema = z13.object({
+  id: z13.string().min(1),
+  object: z13.literal("social_upload"),
+  identity_id: idOf("idn"),
+  type: z13.enum(["image", "video", "document"]),
+  url: z13.url().nullable()
+});
+var SocialAnalyticsSchema = z13.object({
+  object: z13.literal("social_analytics"),
+  identity_id: idOf("idn"),
+  resource_id: z13.string().min(1),
+  platform: SocialPlatformSchema.nullable(),
+  data: z13.unknown()
+});
+var SocialCommentSchema = z13.object({
+  id: z13.string().min(1),
+  object: z13.literal("social_comment"),
+  identity_id: idOf("idn"),
+  post_id: z13.string().min(1),
+  platforms: z13.array(SocialPlatformSchema),
+  status: SocialPostStatusSchema,
+  posted_at: Timestamp.nullable(),
+  data: z13.unknown()
+});
+
+// src/define.ts
+import { z as z14 } from "zod";
+
+// src/template.ts
+var BLUEPRINTS = {
+  /** Clients, pipeline, deliverables, calendar. */
+  agency: { templates: ["blank", "seo-geo"], default: "blank" },
+  /** Post queue, accounts, calendar, analytics. */
+  media: { templates: ["faceless", "clipping"] }
+};
+var list = (names) => names.join(", ");
+function chooseTemplate(blueprint, template) {
+  if (blueprint === void 0) {
+    if (template === void 0) return { ok: true, template: void 0 };
+    return {
+      ok: false,
+      message: `template "${template}" names no blueprint \u2014 a template belongs to one, so add \`blueprint: "\u2026"\` (${list(Object.keys(BLUEPRINTS))})`
+    };
+  }
+  const known = BLUEPRINTS[blueprint];
+  if (known === void 0) {
+    return { ok: false, message: `blueprint "${blueprint}" is not a blueprint \u2014 the blueprints are ${list(Object.keys(BLUEPRINTS))}` };
+  }
+  if (template === void 0) {
+    if (known.default !== void 0) return { ok: true, template: known.default };
+    return {
+      ok: false,
+      message: `blueprint "${blueprint}" needs a template \u2014 choose one of ${list(known.templates)}. Its crews spend money in different ways, so there is no default to fall back to.`
+    };
+  }
+  if (!known.templates.includes(template)) {
+    return { ok: false, message: `template "${template}" is not a template of blueprint "${blueprint}" \u2014 its templates are ${list(known.templates)}` };
+  }
+  return { ok: true, template };
+}
+
+// src/define.ts
+var BlueprintRefusal = class extends Error {
+  name = "BlueprintRefusal";
+};
+var EnvValueSchema = z14.union([z14.string(), z14.object({ from_env: z14.string().min(1) })]);
+var AppDeclSchema = z14.object({
+  /** Becomes a hostname, so the grammar is the platform's `APP_NAME` (a DNS label). */
+  name: z14.string().regex(APP_NAME, "a lowercase DNS label, 63 characters or fewer"),
+  type: AppTypeSchema,
+  description: z14.string().optional(),
+  /** A directory whose files are collected and shipped as the app's file-map deployment. */
+  deploy_dir: z14.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: z14.record(z14.string().regex(ENV_NAME), EnvValueSchema, { error: "keyed by environment variable name (A-Z, 0-9, _)" }).optional()
+});
+var ScheduleDeclSchema = z14.object({
+  cron: z14.string().min(1),
+  timezone: z14.string().min(1).optional(),
+  /** The message every fire opens its session with (`input_template` on the wire). */
+  input: z14.string().min(1),
+  budget_micro_usd: MicroUsdField.nonnegative(),
+  identity: z14.string().min(1).optional(),
+  enabled: z14.boolean().optional()
+});
+var AgentDeclSchema = z14.object({
+  name: z14.string().min(1),
+  model: z14.string().min(1),
+  budget: BudgetSchema,
+  description: z14.string().optional(),
+  system: z14.string().optional(),
+  tools: ToolsetSchema.optional(),
+  skills: z14.array(SkillRefSchema).optional(),
+  mcp_servers: z14.array(McpServerSchema).optional(),
+  /** Declared app *names*; `up` resolves them to `app_` ids in `tools.configs.apps` (§29.3). */
+  allowed_apps: z14.array(z14.string()).optional(),
+  /** A declared identity *name*; `up` attaches it after the agent upsert (§22). */
+  identity: z14.string().min(1).optional(),
+  /** The agent's deployments as a complete set: declared → owned, and the rest are pruned (ADR-0355). */
+  schedules: z14.array(ScheduleDeclSchema).optional()
+});
+var CredentialDeclSchema = z14.object({
+  kind: VaultCredentialKindSchema,
+  key: z14.string().min(1).max(128),
+  /** The one exact destination host an `env_var` is bound to. */
+  host: z14.string().min(1).optional(),
+  /** The MCP server URL a `static_bearer` / `mcp_oauth` token is matched to. */
+  mcp_server_url: z14.url().optional(),
+  value: z14.object({ from_env: z14.string().min(1) })
+});
+var VaultDeclSchema = z14.object({
+  name: VaultSchema.shape.display_name,
+  identity: z14.string().min(1).optional(),
+  credentials: z14.array(CredentialDeclSchema)
+});
+var SkillDeclSchema = z14.object({
+  slug: z14.string().regex(/^[a-z0-9][a-z0-9-]*$/, "lowercase letters, digits and dashes"),
+  file: z14.string().min(1)
+});
+var IdentityDeclSchema = IdentitySchema.pick({ name: true, description: true }).partial({
+  description: true
+});
+var RemovedSchema = z14.object({
+  apps: z14.array(z14.string().min(1)).default([]),
+  agents: z14.array(z14.string().min(1)).default([]),
+  skills: z14.array(z14.string().min(1)).default([]),
+  identities: z14.array(z14.string().min(1)).default([]),
+  vaults: z14.array(z14.string().min(1)).default([])
+});
+var KeptSchema = z14.object({ agents: z14.array(z14.string().min(1)).default([]) });
+var ProjectSchema = z14.object({
+  name: z14.string().min(1),
+  /** The machine this project runs: its repo, its screens, its `/api/*` (`template.ts`). */
+  blueprint: z14.string().min(1).optional(),
+  /** Which of that blueprint's templates provides the crew; a blueprint with a default may omit it. */
+  template: z14.string().min(1).optional(),
+  skills: z14.array(SkillDeclSchema).default([]),
+  identities: z14.array(IdentityDeclSchema).default([]),
+  vaults: z14.array(VaultDeclSchema).default([]),
+  apps: z14.array(AppDeclSchema).default([]),
+  agents: z14.array(AgentDeclSchema).default([]),
+  removed: RemovedSchema.default({ apps: [], agents: [], skills: [], identities: [], vaults: [] }),
+  kept: KeptSchema.default({ agents: [] })
+});
+function refuse(message3) {
+  throw new BlueprintRefusal(message3);
+}
+function assertUniqueNames(kind, names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name)) {
+      refuse(`duplicate ${kind} name "${name}" \u2014 resources are keyed by name, so each ${kind} must be declared exactly once`);
+    }
+    seen.add(name);
+  }
+}
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function applyChoice(config) {
+  const chosen = chooseTemplate(config.blueprint, config.template);
+  if (!chosen.ok) refuse(chosen.message);
+  if (chosen.template !== void 0) config.template = chosen.template;
+}
+function parseProject(input) {
+  const parsed = ProjectSchema.safeParse(input);
+  if (!parsed.success) {
+    const lines = parsed.error.issues.map((i) => `${i.path.join(".") || "config"}: ${i.message}`);
+    refuse(`invalid project config \u2014 ${lines.join("; ")}`);
+  }
+  const config = parsed.data;
+  applyChoice(config);
+  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]);
+  assertUniqueNames("skill", [...config.skills.map((s) => s.slug), ...config.removed.skills]);
+  assertUniqueNames("identity", [...config.identities.map((i) => i.name), ...config.removed.identities]);
+  assertUniqueNames("vault", [...config.vaults.map((v) => v.name), ...config.removed.vaults]);
+  const appNames = new Set(config.apps.map((a) => a.name));
+  for (const app of config.apps) {
+    if (app.type === "frontend_only" && app.mcp !== void 0) {
+      refuse(`app "${app.name}": mcp is set, but a frontend_only app has no server to answer on it \u2014 declare type "fullstack" or drop mcp`);
+    }
+  }
+  const identityNames = new Set(config.identities.map((i) => i.name));
+  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`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const credential of vault.credentials) {
+      if (credential.kind === "env_var") {
+        refuse(
+          `vault "${vault.name}": credential "${credential.key}" is an env_var, which needs substitution at the sandbox egress boundary \u2014 not available on this platform, so the API would refuse it; use a static_bearer or mcp_oauth credential with an mcp_server_url, which is injected before the sandbox sees it`
+        );
+      }
+      const at = [credential.kind, credential.key, credential.host ?? credential.mcp_server_url ?? ""].join(" ");
+      if (seen.has(at)) {
+        refuse(`vault "${vault.name}": credential ${credential.kind} "${credential.key}" is declared twice for the same destination \u2014 credentials are matched to live rows by kind, key and destination, so each must be unique per vault`);
+      }
+      seen.add(at);
+    }
+  }
+  for (const agent of config.agents) {
+    for (const name of agent.allowed_apps ?? []) {
+      if (!appNames.has(name)) {
+        refuse(`agent "${agent.name}": allowed_apps names "${name}", but no app with that name is declared in this project`);
+      }
+    }
+    if (agent.identity !== void 0 && !identityNames.has(agent.identity)) {
+      refuse(`agent "${agent.name}": identity names "${agent.identity}", but no identity with that name is declared in this project`);
+    }
+    const crons = /* @__PURE__ */ new Set();
+    for (const schedule of agent.schedules ?? []) {
+      if (crons.has(schedule.cron)) {
+        refuse(`agent "${agent.name}": schedule cron "${schedule.cron}" is declared twice \u2014 schedules are matched to live deployments by cron, so each must be unique per agent`);
+      }
+      crons.add(schedule.cron);
+      if (schedule.identity !== void 0 && !identityNames.has(schedule.identity)) {
+        refuse(`agent "${agent.name}": schedule "${schedule.cron}" identity names "${schedule.identity}", but no identity with that name is declared in this project`);
+      }
+    }
+  }
+  return deepFreeze(config);
+}
+function withTemplate(input, templates) {
+  const chosen = chooseTemplate(input.blueprint, input.template);
+  if (!chosen.ok) refuse(chosen.message);
+  if (chosen.template === void 0) refuse('templates are declared but no blueprint is \u2014 add `blueprint: "\u2026"`');
+  const declared = BLUEPRINTS[input.blueprint].templates;
+  const carried = templates.map((one) => one.name);
+  if ([...declared].sort().join(" ") !== [...carried].sort().join(" ")) {
+    refuse(
+      `blueprint "${input.blueprint}" has templates ${declared.join(", ")}, but this repo carries ${carried.join(", ") || "none"} \u2014 one repo carries every template of its blueprint, so switching is an edit and never a re-clone`
+    );
+  }
+  const picked = templates.find((one) => one.name === chosen.template);
+  const agents = [...picked.agents, ...input.agents ?? []];
+  const mine = new Set(agents.map((one) => one.name));
+  const removed = new Set(input.removed?.agents ?? []);
+  const kept = templates.filter((one) => one.name !== chosen.template).flatMap((one) => one.agents.map((agent) => agent.name)).filter((name) => !mine.has(name) && !removed.has(name));
+  return { ...input, template: chosen.template, agents, kept: { agents: [.../* @__PURE__ */ new Set([...input.kept?.agents ?? [], ...kept])] } };
+}
+function defineProject({ templates, ...input }) {
+  return parseProject(templates === void 0 ? input : withTemplate(input, templates));
+}
+
+// src/load.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var CONFIG_CANDIDATES = [
+  "naive.config.ts",
+  "naive.config.js",
+  "naive.config.mjs",
+  "naive.config.json"
+];
+function isMissingModule(error) {
+  const code = error?.code;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validate(path, raw) {
+  try {
+    return { ok: true, path, config: parseProject(raw) };
+  } catch (error) {
+    if (error instanceof BlueprintRefusal) return { ok: false, reason: "invalid", message: error.message };
+    throw error;
+  }
+}
+async function loadConfig(dir) {
+  const path = CONFIG_CANDIDATES.map((name) => resolve(join(dir, name))).find(existsSync);
+  if (!path) {
+    return {
+      ok: false,
+      reason: "not_found",
+      message: `no ${CONFIG_CANDIDATES.join(" / ")} in ${dir}`
+    };
+  }
+  if (path.endsWith(".json")) {
+    try {
+      return validate(path, JSON.parse(readFileSync(path, "utf8")));
+    } catch (error) {
+      if (error instanceof SyntaxError) return { ok: false, reason: "invalid", message: message(error) };
+      throw error;
+    }
+  }
+  let importFile;
+  try {
+    const { createJiti } = await import("jiti");
+    importFile = createJiti(pathToFileURL(path).href).import;
+  } catch (error) {
+    return { ok: false, reason: "unloadable", message: message(error) };
+  }
+  let raw;
+  try {
+    const mod = await importFile(path);
+    raw = mod?.default ?? mod;
+  } catch (error) {
+    return { ok: false, reason: isMissingModule(error) ? "unloadable" : "invalid", message: message(error) };
+  }
+  if (raw === null || typeof raw !== "object") {
+    return {
+      ok: false,
+      reason: "invalid",
+      message: `${path} evaluated to ${raw === void 0 ? "undefined" : typeof raw}; it must \`export default defineProject({...})\``
+    };
+  }
+  return validate(path, raw);
+}
+
+// src/up.ts
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+
+// src/report.ts
+import { ApiError, send } from "@usenaive-sdk/vetta";
+import { z as z15 } from "zod";
+function message2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function attempt(into, name, work) {
+  let line;
+  try {
+    line = await work();
+  } catch (error) {
+    line = { name, action: "refused", reason: message2(error) };
+  }
+  into.push(line);
+  return line;
+}
+var canonical = (value) => {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonical(value[key])])
+  );
+};
+var changed = (declared, live) => declared !== void 0 && JSON.stringify(canonical(declared)) !== JSON.stringify(canonical(live));
+async function absent(work) {
+  try {
+    return await work;
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) return null;
+    throw error;
+  }
+}
+var PageShape = z15.object({
+  data: z15.array(z15.unknown()),
+  has_more: z15.boolean(),
+  next_cursor: z15.string().nullable()
+});
+function rowLabel(row) {
+  const { object, id } = row ?? {};
+  const words = [object, id].filter((one) => typeof one === "string");
+  return words.length > 0 ? words.join(" ") : "a row";
+}
+var why = (error) => error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+async function listAll(config, path, item, skipped, query = {}) {
+  const rows = [];
+  let after;
+  for (; ; ) {
+    const response = await send(config, { method: "GET", path, query: { ...query, limit: 100, after } }, "application/json");
+    const text = await response.text();
+    if (!response.ok) throw new Error(`could not list ${path} (HTTP ${response.status})`);
+    const body = PageShape.parse(JSON.parse(text));
+    for (const row of body.data) {
+      const parsed = item.safeParse(row);
+      if (parsed.success) rows.push(parsed.data);
+      else skipped.push(`${rowLabel(row)} in ${path} could not be read and was skipped: ${why(parsed.error)}`);
+    }
+    if (!body.has_more || body.next_cursor === null) return rows;
+    after = body.next_cursor;
+  }
+}
+async function tombstone(name, current, remove, dryRun) {
+  if (!current) return { name, action: "unchanged", reason: "already absent" };
+  if (!dryRun) await remove(current.id);
+  return { name, action: "deleted", id: current.id };
+}
+
+// src/agents.ts
+function desiredTools(decl, current, ids) {
+  if (decl.allowed_apps === void 0) return decl.tools;
+  const base = decl.tools ?? current?.tools ?? { default_config: { permission: "allow" }, configs: {} };
+  const appsTool = base.configs["apps"] ?? { enabled: true, permission: base.default_config.permission };
+  return {
+    default_config: base.default_config,
+    configs: {
+      ...base.configs,
+      apps: { ...appsTool, config: { ...appsTool.config, allowed_apps: ids } }
+    }
+  };
+}
+async function createAgent(client, decl, tools, identityId) {
+  const created = await client.agents.create({
+    name: decl.name,
+    model: decl.model,
+    budget: decl.budget,
+    ...decl.description !== void 0 ? { description: decl.description } : {},
+    ...decl.system !== void 0 ? { system: decl.system } : {},
+    ...decl.skills !== void 0 ? { skills: decl.skills } : {},
+    ...decl.mcp_servers !== void 0 ? { mcp_servers: decl.mcp_servers } : {},
+    ...tools !== void 0 ? { tools } : {}
+  });
+  if (identityId !== void 0) await client.identities.attach(created.id, identityId);
+  return { name: decl.name, action: "created", id: created.id };
+}
+async function upsertAgent(client, decl, existing, ids, dryRun) {
+  const unresolved = (decl.allowed_apps ?? []).filter((name) => !ids.apps.has(name));
+  const identityId = decl.identity === void 0 ? void 0 : ids.identities.get(decl.identity);
+  const missing = unresolved.length > 0 ? `allowed_apps needs app "${unresolved[0]}"` : decl.identity !== void 0 && identityId === void 0 ? `identity needs "${decl.identity}"` : null;
+  if (missing !== null && !dryRun) {
+    return { name: decl.name, action: "refused", reason: `${missing}, which was not provisioned in this run` };
+  }
+  const appIds = (decl.allowed_apps ?? []).flatMap((name) => ids.apps.get(name) ?? []);
+  const current = existing.find((agent) => agent.name === decl.name) ?? null;
+  const tools = desiredTools(decl, current, appIds);
+  if (!current) return dryRun ? { name: decl.name, action: "created" } : createAgent(client, decl, tools, identityId);
+  const patch = {};
+  if (changed(decl.model, current.model)) patch.model = decl.model;
+  if (changed(decl.budget, current.budget)) patch.budget = decl.budget;
+  if (changed(decl.description, current.description)) patch.description = decl.description;
+  if (changed(decl.system, current.system)) patch.system = decl.system;
+  if (changed(decl.skills, current.skills)) patch.skills = decl.skills;
+  if (changed(decl.mcp_servers, current.mcp_servers)) patch.mcp_servers = decl.mcp_servers;
+  if (changed(tools, current.tools)) patch.tools = tools;
+  const held = identityId === void 0 ? [] : (await client.identities.held(current.id)).data;
+  const grant = identityId === void 0 || held.some((one) => one.id === identityId) ? null : identityId;
+  const drifted = Object.keys(patch).length > 0 || missing !== null || grant !== null;
+  if (!drifted) return { name: decl.name, action: "unchanged", id: current.id };
+  if (!dryRun) {
+    if (Object.keys(patch).length > 0) await client.agents.update(current.id, patch);
+    if (grant !== null) await client.identities.attach(current.id, grant);
+  }
+  return { name: decl.name, action: "updated", id: current.id };
+}
+async function upsertSchedule(client, agent, decl, current, identityIds, dryRun) {
+  const name = `${agent.name} @ ${decl.cron}`;
+  if (agent.action === "refused") throw new Error(`agent "${agent.name}" was not provisioned in this run`);
+  const identity = decl.identity === void 0 ? void 0 : identityIds.get(decl.identity);
+  const unresolved = decl.identity !== void 0 && identity === void 0;
+  if (unresolved && !dryRun) throw new Error(`identity needs "${decl.identity}", which was not provisioned in this run`);
+  if (!current) {
+    if (dryRun || agent.id === void 0) return { name, action: "created" };
+    const created = await client.deployments.create({
+      agent_id: agent.id,
+      cron: decl.cron,
+      input_template: decl.input,
+      budget_micro_usd: decl.budget_micro_usd,
+      ...decl.timezone !== void 0 ? { timezone: decl.timezone } : {},
+      ...identity !== void 0 ? { identity } : {},
+      ...decl.enabled !== void 0 ? { enabled: decl.enabled } : {}
+    });
+    return { name, action: "created", id: created.id };
+  }
+  const patch = {};
+  if (changed(decl.timezone, current.timezone)) patch.timezone = decl.timezone;
+  if (changed(decl.input, current.input_template)) patch.input_template = decl.input;
+  if (changed(decl.budget_micro_usd, current.budget_micro_usd)) patch.budget_micro_usd = decl.budget_micro_usd;
+  if (changed(identity, current.identity)) patch.identity = identity;
+  if (changed(decl.enabled, current.enabled)) patch.enabled = decl.enabled;
+  if (Object.keys(patch).length === 0 && !unresolved) return { name, action: "unchanged", id: current.id };
+  if (!dryRun) await client.deployments.update(current.id, patch);
+  return { name, action: "updated", id: current.id };
+}
+async function reconcileSchedules(client, agent, declared, live, identityIds, dryRun, into) {
+  const rows = live.filter((row) => row.agent_id === agent.id);
+  for (const decl of declared) {
+    const current = rows.find((row) => row.cron === decl.cron);
+    await attempt(into, `${agent.name} @ ${decl.cron}`, () => upsertSchedule(client, agent, decl, current, identityIds, dryRun));
+  }
+  for (const row of rows.filter((row2) => !declared.some((decl) => decl.cron === row2.cron))) {
+    const name = `${agent.name} @ ${row.cron}`;
+    await attempt(into, name, () => tombstone(name, row, (id) => client.deployments.delete(id), dryRun));
+  }
+}
+
+// src/apps.ts
+import { createHash as createHash2 } from "node:crypto";
+import { resolve as resolve2 } from "node:path";
+
+// src/files.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
+import { join as join2, relative, sep } from "node:path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+var MAX_FILE_BYTES = 8 * 1024 * 1024;
+function collectFiles(root) {
+  const files = {};
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".env")) continue;
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && statSync(full).size <= MAX_FILE_BYTES) {
+        files[relative(root, full).split(sep).join("/")] = readFileSync2(full).toString("base64");
+      }
+    }
+  };
+  walk(root);
+  return files;
+}
+function contentHash(files) {
+  const hash = createHash("sha256");
+  for (const [path, base64] of Object.entries(files).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    const bytes = Buffer.from(base64, "base64");
+    hash.update(`${path}\0${bytes.length}\0`).update(bytes);
+  }
+  return hash.digest("hex");
+}
+
+// src/apps.ts
+async function findApp(client, name, skipped) {
+  const rows = await listAll(client.config, "/v1/apps", AppSchema, skipped, { name });
+  return rows.find((app) => app.name === name) ?? null;
+}
+function ownershipRefusal(name, project, owner) {
+  const held = owner === null ? "no project (it was created outside a blueprint)" : `project "${owner}"`;
+  const verb = owner === null ? "take" : "transfer";
+  return `app "${name}" is owned by ${held}; this project is "${project}". Rename the app in your config, or re-run \`naive up --adopt\` to ${verb} it.`;
+}
+var ensureApp = (client, body) => client.apps.create(body);
+function resolveEnv(decl) {
+  const env = {};
+  for (const [name, value] of Object.entries(decl.env ?? {})) {
+    if (typeof value === "string") {
+      env[name] = value;
+      continue;
+    }
+    const local = process.env[value.from_env];
+    if (local === void 0) throw new Error(`env ${name} reads local variable ${value.from_env}, which is not set`);
+    env[name] = local;
+  }
+  return env;
+}
+function secretHash(name, value) {
+  return createHash2("sha256").update(`${name}\0`).update(value).digest("hex");
+}
+function localTree(decl, dir) {
+  if (!decl.deploy_dir) return null;
+  const files = collectFiles(resolve2(dir, decl.deploy_dir));
+  return { files, hash: contentHash(files) };
+}
+async function writeApp(client, id, env, tree) {
+  for (const [name, value] of Object.entries(env)) {
+    await client.apps.setSecret(id, { name, value, value_hash: secretHash(name, value) });
+  }
+  if (!tree) return;
+  await client.apps.deploy(id, tree.files, tree.hash);
+  await settleDeploy(client, id);
+}
+var SETTLE_TRIES = 30;
+var SETTLE_MS = 4e3;
+async function settleDeploy(client, id) {
+  for (let poll = 0; poll < SETTLE_TRIES; poll++) {
+    const newest = (await client.apps.deployments(id, { limit: 1 })).data[0];
+    if (newest === void 0 || newest.status === "ready" || newest.status === "error") return;
+    await new Promise((resolve4) => setTimeout(resolve4, SETTLE_MS));
+  }
+}
+async function createApp(client, decl, env, opts, appIds) {
+  const created = await ensureApp(client, {
+    name: decl.name,
+    type: decl.type,
+    project: opts.project,
+    ...decl.description !== void 0 ? { description: decl.description } : {},
+    ...decl.mcp !== void 0 ? { mcp: decl.mcp } : {}
+  });
+  appIds.set(decl.name, created.id);
+  await writeApp(client, created.id, env, localTree(decl, opts.dir));
+  return { name: decl.name, action: "created", id: created.id, url: (await client.apps.get(created.id)).url };
+}
+async function upsertApp(client, decl, opts, appIds) {
+  const env = resolveEnv(decl);
+  const names = Object.keys(env);
+  const note = (notes) => notes.length > 0 ? { reason: notes.join("; ") } : {};
+  const mcpPlan = decl.mcp !== void 0 ? [`will set mcp ${decl.mcp}`] : [];
+  const current = await findApp(client, decl.name, opts.skipped);
+  if (!current) {
+    const willSet = names.length > 0 ? [`will set ${names.join(", ")}`] : [];
+    if (opts.dryRun) {
+      return {
+        name: decl.name,
+        action: "created",
+        ...note([...willSet, ...mcpPlan, ...decl.deploy_dir ? [`will deploy ${decl.deploy_dir}`] : []])
+      };
+    }
+    return createApp(client, decl, env, opts, appIds);
+  }
+  const owned = current.project === opts.project;
+  if (!owned && !opts.adopt) {
+    return {
+      name: decl.name,
+      action: "refused",
+      id: current.id,
+      reason: ownershipRefusal(decl.name, opts.project, current.project)
+    };
+  }
+  appIds.set(decl.name, current.id);
+  if (current.type !== decl.type) {
+    return {
+      name: decl.name,
+      action: "refused",
+      id: current.id,
+      reason: `app "${decl.name}" exists as ${current.type} and type cannot change; delete it or declare type "${current.type}"`
+    };
+  }
+  const from = current.project === null ? "(previously unowned)" : `from project "${current.project}"`;
+  const adoption = owned ? [] : [`${opts.dryRun ? "will adopt" : "adopted"} ${from}`];
+  if (!owned && !opts.dryRun) {
+    await ensureApp(client, { name: decl.name, type: decl.type, project: opts.project, adopt: true });
+  }
+  const live = decl.env === void 0 ? [] : (await client.apps.secrets(current.id)).data;
+  const unmanaged = live.map((secret) => secret.name).filter((name) => !(name in env));
+  const held = new Map(live.map((secret) => [secret.name, secret.value_hash]));
+  const staleEnv = Object.fromEntries(
+    Object.entries(env).filter(([name, value]) => held.get(name) !== secretHash(name, value))
+  );
+  const staleNames = Object.keys(staleEnv);
+  const patch = {
+    ...decl.description !== void 0 && decl.description !== current.description ? { description: decl.description } : {},
+    ...(decl.mcp ?? null) !== current.mcp ? { mcp: decl.mcp ?? null } : {}
+  };
+  const drifted = Object.keys(patch).length > 0;
+  const tree = localTree(decl, opts.dir);
+  const newest = tree ? (await client.apps.deployments(current.id, { limit: 1 })).data[0] : void 0;
+  const stale = tree !== null && newest?.content_hash !== tree.hash;
+  const action = !owned || drifted || stale || staleNames.length > 0 ? "updated" : "unchanged";
+  const plan = opts.dryRun ? [
+    ...staleNames.length > 0 ? [`will set ${staleNames.join(", ")}`] : [],
+    ..."mcp" in patch ? patch.mcp === null ? ["will clear mcp"] : mcpPlan : [],
+    ...decl.deploy_dir ? [stale ? `will deploy ${decl.deploy_dir}` : `${decl.deploy_dir} unchanged`] : []
+  ] : [];
+  if (!opts.dryRun) {
+    if (drifted) await client.apps.update(current.id, { ...patch, project: opts.project });
+    await writeApp(client, current.id, staleEnv, stale ? tree : null);
+  }
+  return {
+    name: decl.name,
+    action,
+    id: current.id,
+    // Re-read only when a build actually ran: a dry run issues no call at all.
+    url: !opts.dryRun && stale ? (await client.apps.get(current.id)).url : current.url,
+    ...note([...adoption, ...plan, ...unmanaged.length > 0 ? [`unmanaged secrets: ${unmanaged.join(", ")}`] : []])
+  };
+}
+
+// src/vaults.ts
+async function upsertVault(client, decl, existing, identityIds, dryRun) {
+  const identityId = decl.identity === void 0 ? void 0 : identityIds.get(decl.identity);
+  if (decl.identity !== void 0 && identityId === void 0 && !dryRun) {
+    return { name: decl.name, action: "refused", reason: `identity needs "${decl.identity}", which was not provisioned in this run` };
+  }
+  const current = existing.find((vault) => vault.display_name === decl.name);
+  if (!current) {
+    if (dryRun) return { name: decl.name, action: "created" };
+    const created = await client.vaults.create({
+      display_name: decl.name,
+      ...identityId !== void 0 ? { identity_id: identityId } : {}
+    });
+    return { name: decl.name, action: "created", id: created.id };
+  }
+  if (identityId !== void 0 && current.identity_id !== identityId) {
+    return {
+      name: decl.name,
+      action: "refused",
+      id: current.id,
+      reason: `vault "${decl.name}" belongs to another identity and that cannot change; remove it or declare the identity it has`
+    };
+  }
+  return { name: decl.name, action: "unchanged", id: current.id };
+}
+async function upsertCredential(client, vault, decl, existing, dryRun) {
+  const name = `${vault.name} / ${decl.key}`;
+  if (vault.action === "refused") throw new Error(`vault "${vault.name}" was not provisioned in this run`);
+  const current = existing.find(
+    (row) => row.kind === decl.kind && row.key === decl.key && row.host === (decl.host ?? null) && row.mcp_server_url === (decl.mcp_server_url ?? null)
+  );
+  if (current) return { name, action: "unchanged", id: current.id };
+  const value = process.env[decl.value.from_env];
+  if (value === void 0) throw new Error(`credential ${decl.key} reads local variable ${decl.value.from_env}, which is not set`);
+  if (dryRun || vault.id === void 0) return { name, action: "created" };
+  const created = await client.vaults.credentials.create(vault.id, {
+    kind: decl.kind,
+    key: decl.key,
+    value,
+    ...decl.host !== void 0 ? { host: decl.host } : {},
+    ...decl.mcp_server_url !== void 0 ? { mcp_server_url: decl.mcp_server_url } : {}
+  });
+  return { name, action: "created", id: created.id };
+}
+
+// src/up.ts
+async function upsertSkill(client, decl, opts) {
+  const content = readFileSync3(resolve3(opts.dir, decl.file), "utf8");
+  const sha256 = createHash3("sha256").update(content).digest("hex");
+  const current = await absent(client.skills.get(decl.slug));
+  const latest = current ? (await client.skills.listVersions(decl.slug, { limit: 1 })).data[0] : void 0;
+  const action = !current ? "created" : latest?.sha256 === sha256 ? "unchanged" : "updated";
+  if (action === "unchanged" || opts.dryRun) {
+    return { name: decl.slug, action, ...current ? { id: current.id } : {} };
+  }
+  const pushed = await client.skills.push({ slug: decl.slug, content, sha256 });
+  return { name: decl.slug, action, id: pushed.id };
+}
+async function upsertIdentity(client, decl, dryRun, identityIds) {
+  const current = await absent(client.identities.get(decl.name));
+  if (!current) {
+    if (dryRun) return { name: decl.name, action: "created" };
+    const created = await client.identities.create({
+      name: decl.name,
+      ...decl.description !== void 0 ? { description: decl.description } : {}
+    });
+    identityIds.set(decl.name, created.id);
+    return { name: decl.name, action: "created", id: created.id };
+  }
+  identityIds.set(decl.name, current.id);
+  const drifted = decl.description !== void 0 && decl.description !== current.description;
+  if (drifted && !dryRun) await client.identities.update(current.id, { description: decl.description ?? null });
+  return { name: decl.name, action: drifted ? "updated" : "unchanged", id: current.id };
+}
+async function applyRemoved(client, removed, live, owner, report) {
+  const dryRun = report.dry_run;
+  for (const name of removed.agents) {
+    const current = live.agents.find((agent) => agent.name === name);
+    await attempt(report.agents, name, () => tombstone(name, current, (id) => client.agents.delete(id), dryRun));
+  }
+  for (const name of removed.apps) {
+    await attempt(report.apps, name, async () => {
+      const current = await findApp(client, name, owner.skipped);
+      if (current !== null && current.project !== owner.project && !owner.adopt) {
+        return { name, action: "refused", id: current.id, reason: ownershipRefusal(name, owner.project, current.project) };
+      }
+      return tombstone(name, current, (id) => client.apps.delete(id), dryRun);
+    });
+  }
+  for (const slug of removed.skills) {
+    await attempt(
+      report.skills,
+      slug,
+      async () => tombstone(slug, await absent(client.skills.get(slug)), (id) => client.skills.delete(id), dryRun)
+    );
+  }
+  for (const name of removed.vaults) {
+    const current = live.vaults.find((vault) => vault.display_name === name);
+    await attempt(report.vaults, name, () => tombstone(name, current, (id) => client.vaults.delete(id), dryRun));
+  }
+  for (const name of removed.identities) {
+    await attempt(
+      report.identities,
+      name,
+      async () => tombstone(name, await absent(client.identities.get(name)), (id) => client.identities.delete(id), dryRun)
+    );
+  }
+}
+var applied = (config) => ({
+  ...config.blueprint !== void 0 ? { blueprint: config.blueprint } : {},
+  ...config.template !== void 0 ? { template: config.template } : {}
+});
+function reportKept(config, live, into) {
+  const by = config.template === void 0 ? "this template" : `template "${config.template}"`;
+  for (const name of config.kept.agents) {
+    const current = live.find((agent) => agent.name === name);
+    if (current !== void 0) into.push({ name, action: "unchanged", id: current.id, reason: `not declared by ${by}; kept, never deleted` });
+  }
+}
+async function up(config, client, opts = {}) {
+  const dryRun = opts.dry_run ?? false;
+  const dir = opts.dir ?? process.cwd();
+  const ids = { apps: /* @__PURE__ */ new Map(), identities: /* @__PURE__ */ new Map() };
+  const report = { dry_run: dryRun, ...applied(config), skills: [], identities: [], vaults: [], apps: [], agents: [], schedules: [], skipped: [] };
+  const owner = { project: config.name, adopt: opts.adopt ?? false, skipped: report.skipped };
+  for (const decl of config.skills) {
+    await attempt(report.skills, decl.slug, () => upsertSkill(client, decl, { dryRun, dir }));
+  }
+  for (const decl of config.identities) {
+    await attempt(report.identities, decl.name, () => upsertIdentity(client, decl, dryRun, ids.identities));
+  }
+  const vaults = config.vaults.length > 0 || config.removed.vaults.length > 0 ? await listAll(client.config, "/v1/vaults", VaultSchema, report.skipped) : [];
+  for (const decl of config.vaults) {
+    const line = await attempt(report.vaults, decl.name, () => upsertVault(client, decl, vaults, ids.identities, dryRun));
+    const vaultId = line.action === "unchanged" ? line.id : void 0;
+    const rows = vaultId === void 0 ? [] : await listAll(client.config, `/v1/vaults/${vaultId}/credentials`, VaultCredentialSchema, report.skipped);
+    for (const cred of decl.credentials) {
+      await attempt(report.vaults, `${decl.name} / ${cred.key}`, () => upsertCredential(client, line, cred, rows, dryRun));
+    }
+  }
+  for (const decl of config.apps) {
+    await attempt(report.apps, decl.name, () => upsertApp(client, decl, { ...owner, dryRun, dir }, ids.apps));
+  }
+  const existing = config.agents.length > 0 || config.removed.agents.length > 0 || config.kept.agents.length > 0 ? await listAll(client.config, "/v1/agents", AgentSchema, report.skipped) : [];
+  const deployments = config.agents.some((decl) => decl.schedules !== void 0) ? await listAll(client.config, "/v1/deployments", DeploymentSchema, report.skipped) : [];
+  for (const decl of config.agents) {
+    const line = await attempt(report.agents, decl.name, () => upsertAgent(client, decl, existing, ids, dryRun));
+    if (decl.schedules !== void 0) {
+      await reconcileSchedules(client, line, decl.schedules, deployments, ids.identities, dryRun, report.schedules);
+    }
+  }
+  reportKept(config, existing, report.agents);
+  await applyRemoved(client, config.removed, { agents: existing, vaults }, owner, report);
+  return report;
+}
+export {
+  BLUEPRINTS,
+  BlueprintRefusal,
+  CONFIG_CANDIDATES,
+  chooseTemplate,
+  defineProject,
+  loadConfig,
+  parseProject,
+  up
+};
+//# sourceMappingURL=index.js.map