@granular-software/sdk 0.4.7 → 0.4.8

package/dist/cli/index.js

@@ -5434,6 +5434,1182 @@ function resolveAuthUrl(explicitAuthUrl, mode) {
   return resolveEndpointMode(mode) === "local" ? LOCAL_AUTH_URL : PRODUCTION_AUTH_URL;
 }
 
+// src/cli/starter-templates.ts
+var DEFAULT_STARTER_TEMPLATE_ID = "library";
+var EFFECTS_SCRIPT_NAME = "granular-effects.ts";
+var SEED_SCRIPT_NAME = "granular-seed.ts";
+function createClassOperation(name, fields) {
+  return {
+    create: name,
+    extends: "@std/class",
+    has: fields
+  };
+}
+function createRelationshipOperation(definition) {
+  return {
+    defineRelationship: definition
+  };
+}
+function createEffectOperation(effect) {
+  return {
+    withEffect: {
+      name: effect.name,
+      description: effect.description,
+      attachedClass: effect.className,
+      isStatic: effect.static,
+      inputSchema: effect.inputSchema,
+      outputSchema: effect.outputSchema
+    }
+  };
+}
+var LIBRARY_TEMPLATE = {
+  id: "library",
+  label: "Library Catalog",
+  summary: "A connected book catalog with clear graph queries and real-world reader actions.",
+  manifestDescription: "A connected book catalog with authors, books, publishers, editors, and external reader actions.",
+  operations: [
+    createClassOperation("author", {
+      name: { type: "string", description: "Author full name" },
+      nationality: { type: "string", description: "Primary nationality or home region" },
+      birth_year: { type: "number", description: "Year of birth" }
+    }),
+    createClassOperation("book", {
+      title: { type: "string", description: "Book title" },
+      isbn: { type: "string", description: "ISBN identifier" },
+      publication_year: { type: "number", description: "Year the book was first published" },
+      price_eur: { type: "number", description: "Current list price in euros" }
+    }),
+    createClassOperation("publisher", {
+      name: { type: "string", description: "Publisher name" },
+      country: { type: "string", description: "Main publishing market" },
+      website: { type: "url", description: "Public website" }
+    }),
+    createClassOperation("editor", {
+      name: { type: "string", description: "Editor full name" },
+      specialty: { type: "string", description: "Editorial focus or genre specialty" },
+      email: { type: "email", description: "Work email address" }
+    }),
+    createRelationshipOperation({
+      left: "author",
+      right: "book",
+      leftSubmodel: "books",
+      rightSubmodel: "authors",
+      leftIsMany: true,
+      rightIsMany: true
+    }),
+    createRelationshipOperation({
+      left: "publisher",
+      right: "book",
+      leftSubmodel: "books",
+      rightSubmodel: "publisher",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "editor",
+      right: "book",
+      leftSubmodel: "books",
+      rightSubmodel: "editor",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "publisher",
+      right: "editor",
+      leftSubmodel: "editors",
+      rightSubmodel: "publisher",
+      leftIsMany: true,
+      rightIsMany: false
+    })
+  ],
+  seedUser: {
+    userId: "reader_demo",
+    name: "Mina Reader",
+    email: "mina@example.com",
+    permissions: ["default"]
+  },
+  seedRecords: [
+    {
+      className: "publisher",
+      id: "rivergate_press",
+      label: "Rivergate Press",
+      fields: {
+        name: "Rivergate Press",
+        country: "France",
+        website: "https://rivergate.example"
+      }
+    },
+    {
+      className: "publisher",
+      id: "northwind_books",
+      label: "Northwind Books",
+      fields: {
+        name: "Northwind Books",
+        country: "United Kingdom",
+        website: "https://northwind.example"
+      }
+    },
+    {
+      className: "editor",
+      id: "maya_chen",
+      label: "Maya Chen",
+      fields: {
+        name: "Maya Chen",
+        specialty: "Speculative fiction",
+        email: "maya.chen@rivergate.example"
+      },
+      relationships: {
+        publisher: "rivergate_press"
+      }
+    },
+    {
+      className: "editor",
+      id: "olivier_marchand",
+      label: "Olivier Marchand",
+      fields: {
+        name: "Olivier Marchand",
+        specialty: "Literary fiction",
+        email: "olivier@northwind.example"
+      },
+      relationships: {
+        publisher: "northwind_books"
+      }
+    },
+    {
+      className: "author",
+      id: "ursula_le_guin",
+      label: "Ursula K. Le Guin",
+      fields: {
+        name: "Ursula K. Le Guin",
+        nationality: "United States",
+        birth_year: 1929
+      }
+    },
+    {
+      className: "author",
+      id: "jrr_tolkien",
+      label: "J.R.R. Tolkien",
+      fields: {
+        name: "J.R.R. Tolkien",
+        nationality: "United Kingdom",
+        birth_year: 1892
+      }
+    },
+    {
+      className: "author",
+      id: "madeline_miller",
+      label: "Madeline Miller",
+      fields: {
+        name: "Madeline Miller",
+        nationality: "United States",
+        birth_year: 1978
+      }
+    },
+    {
+      className: "book",
+      id: "left_hand_of_darkness",
+      label: "The Left Hand of Darkness",
+      fields: {
+        title: "The Left Hand of Darkness",
+        isbn: "978-0-441-47812-5",
+        publication_year: 1969,
+        price_eur: 14
+      },
+      relationships: {
+        authors: ["ursula_le_guin"],
+        publisher: "rivergate_press",
+        editor: "maya_chen"
+      }
+    },
+    {
+      className: "book",
+      id: "wizard_of_earthsea",
+      label: "A Wizard of Earthsea",
+      fields: {
+        title: "A Wizard of Earthsea",
+        isbn: "978-0-547-77274-1",
+        publication_year: 1968,
+        price_eur: 12
+      },
+      relationships: {
+        authors: ["ursula_le_guin"],
+        publisher: "rivergate_press",
+        editor: "maya_chen"
+      }
+    },
+    {
+      className: "book",
+      id: "lord_of_the_rings",
+      label: "The Lord of the Rings",
+      fields: {
+        title: "The Lord of the Rings",
+        isbn: "978-0-618-64015-7",
+        publication_year: 1954,
+        price_eur: 19
+      },
+      relationships: {
+        authors: ["jrr_tolkien"],
+        publisher: "northwind_books",
+        editor: "olivier_marchand"
+      }
+    },
+    {
+      className: "book",
+      id: "song_of_achilles",
+      label: "The Song of Achilles",
+      fields: {
+        title: "The Song of Achilles",
+        isbn: "978-0-06-206062-4",
+        publication_year: 2011,
+        price_eur: 16
+      },
+      relationships: {
+        authors: ["madeline_miller"],
+        publisher: "northwind_books",
+        editor: "olivier_marchand"
+      }
+    }
+  ],
+  runtimeSetup: [
+    "const bookmarkLog: Array<{ bookmarkId: string; bookId: string; userId: string; collection: string; note?: string }> = [];",
+    "const orderLog: Array<{ orderId: string; bookId: string; format: string; quantity: number; userId: string }> = [];",
+    "const followLog: Array<{ subscriptionId: string; authorId: string; channel: string; userId: string }> = [];",
+    "const deliveryLog: Array<{ deliveryId: string; email: string; bookIds: string[]; requestedBy: string }> = [];"
+  ],
+  effects: [
+    {
+      name: "bookmark",
+      description: "Save this book to the current reader bookmark service",
+      className: "book",
+      inputSchema: {
+        type: "object",
+        properties: {
+          collection: { type: "string", description: "Destination collection name" },
+          note: { type: "string", description: "Optional note attached to the bookmark" }
+        }
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          bookmarkId: { type: "string" },
+          status: { type: "string" },
+          savedIn: { type: "string" }
+        },
+        required: ["bookmarkId", "status", "savedIn"]
+      },
+      handlerBody: `const bookmarkId = createId('bookmark');
+      const collection = input.collection ?? 'saved';
+      bookmarkLog.push({
+        bookmarkId,
+        bookId: objectId,
+        userId: ctx.user.userId,
+        collection,
+        note: input.note,
+      });
+      return {
+        bookmarkId,
+        status: 'saved',
+        savedIn: collection,
+      };`
+    },
+    {
+      name: "buy",
+      description: "Create a checkout order for this book in the commerce system",
+      className: "book",
+      inputSchema: {
+        type: "object",
+        properties: {
+          format: { type: "string", description: "Requested format such as paperback, ebook, or audio" },
+          quantity: { type: "number", description: "How many copies to order" }
+        },
+        required: ["format"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string" },
+          status: { type: "string" },
+          checkoutUrl: { type: "string" }
+        },
+        required: ["orderId", "status", "checkoutUrl"]
+      },
+      handlerBody: `const orderId = createId('order');
+      const quantity = typeof input.quantity === 'number' ? input.quantity : 1;
+      const format = input.format ?? 'paperback';
+      orderLog.push({
+        orderId,
+        bookId: objectId,
+        format,
+        quantity,
+        userId: ctx.user.userId,
+      });
+      return {
+        orderId,
+        status: 'checkout_created',
+        checkoutUrl: \`https://checkout.example/orders/\${orderId}\`,
+      };`
+    },
+    {
+      name: "follow",
+      description: "Subscribe the current reader to updates about this author",
+      className: "author",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "Notification channel such as email or push" }
+        },
+        required: ["channel"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          subscriptionId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["subscriptionId", "status"]
+      },
+      handlerBody: `const subscriptionId = createId('follow');
+      followLog.push({
+        subscriptionId,
+        authorId: objectId,
+        channel: input.channel,
+        userId: ctx.user.userId,
+      });
+      return {
+        subscriptionId,
+        status: 'subscribed',
+      };`
+    },
+    {
+      name: "send_curated_list",
+      description: "Send a curated list of books through an external email workflow",
+      inputSchema: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Destination email address" },
+          bookIds: { type: "array", items: { type: "string" }, description: "Books to include in the list" },
+          message: { type: "string", description: "Optional note for the recipient" }
+        },
+        required: ["email", "bookIds"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          deliveryId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["deliveryId", "status"]
+      },
+      handlerBody: `const deliveryId = createId('delivery');
+      deliveryLog.push({
+        deliveryId,
+        email: input.email,
+        bookIds: Array.isArray(input.bookIds) ? input.bookIds : [],
+        requestedBy: ctx.user.userId,
+      });
+      return {
+        deliveryId,
+        status: 'queued',
+      };`
+    }
+  ]
+};
+var SUPPORT_TEMPLATE = {
+  id: "support",
+  label: "Support Operations",
+  summary: "A service graph that connects customers, orders, tickets, and agents.",
+  manifestDescription: "A support operations graph that models customers, orders, tickets, agents, and external actions.",
+  operations: [
+    createClassOperation("customer", {
+      name: { type: "string", description: "Customer display name" },
+      email: { type: "email", description: "Customer email address" },
+      segment: { type: "string", description: "Customer segment such as self-serve or enterprise" }
+    }),
+    createClassOperation("order", {
+      number: { type: "string", description: "Order number shown to the customer" },
+      total_eur: { type: "number", description: "Order total in euros" },
+      status: { type: "string", description: "Current fulfillment status" }
+    }),
+    createClassOperation("ticket", {
+      subject: { type: "string", description: "Support ticket subject" },
+      priority: { type: "string", description: "Priority label" },
+      channel: { type: "string", description: "Where the request came from" }
+    }),
+    createClassOperation("agent", {
+      name: { type: "string", description: "Agent display name" },
+      team: { type: "string", description: "Owning support team" },
+      timezone: { type: "string", description: "Primary working timezone" }
+    }),
+    createRelationshipOperation({
+      left: "customer",
+      right: "order",
+      leftSubmodel: "orders",
+      rightSubmodel: "customer",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "customer",
+      right: "ticket",
+      leftSubmodel: "tickets",
+      rightSubmodel: "customer",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "order",
+      right: "ticket",
+      leftSubmodel: "tickets",
+      rightSubmodel: "order",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "agent",
+      right: "ticket",
+      leftSubmodel: "tickets",
+      rightSubmodel: "assignee",
+      leftIsMany: true,
+      rightIsMany: false
+    })
+  ],
+  seedUser: {
+    userId: "support_demo",
+    name: "Taylor Support",
+    email: "taylor@example.com",
+    permissions: ["default"]
+  },
+  seedRecords: [
+    {
+      className: "customer",
+      id: "acme",
+      label: "Acme Studio",
+      fields: {
+        name: "Acme Studio",
+        email: "ops@acme.example",
+        segment: "enterprise"
+      }
+    },
+    {
+      className: "customer",
+      id: "lumen",
+      label: "Lumen Shop",
+      fields: {
+        name: "Lumen Shop",
+        email: "hello@lumen.example",
+        segment: "self-serve"
+      }
+    },
+    {
+      className: "agent",
+      id: "nina",
+      label: "Nina Patel",
+      fields: {
+        name: "Nina Patel",
+        team: "Billing",
+        timezone: "Europe/Paris"
+      }
+    },
+    {
+      className: "agent",
+      id: "omar",
+      label: "Omar Silva",
+      fields: {
+        name: "Omar Silva",
+        team: "Logistics",
+        timezone: "America/New_York"
+      }
+    },
+    {
+      className: "order",
+      id: "ord_1001",
+      label: "Order 1001",
+      fields: {
+        number: "1001",
+        total_eur: 249,
+        status: "processing"
+      },
+      relationships: {
+        customer: "acme"
+      }
+    },
+    {
+      className: "order",
+      id: "ord_1002",
+      label: "Order 1002",
+      fields: {
+        number: "1002",
+        total_eur: 78,
+        status: "shipped"
+      },
+      relationships: {
+        customer: "lumen"
+      }
+    },
+    {
+      className: "ticket",
+      id: "ticket_401",
+      label: "Missing invoice PDF",
+      fields: {
+        subject: "Missing invoice PDF",
+        priority: "high",
+        channel: "email"
+      },
+      relationships: {
+        customer: "acme",
+        order: "ord_1001",
+        assignee: "nina"
+      }
+    },
+    {
+      className: "ticket",
+      id: "ticket_402",
+      label: "Delivery address update",
+      fields: {
+        subject: "Delivery address update",
+        priority: "normal",
+        channel: "chat"
+      },
+      relationships: {
+        customer: "lumen",
+        order: "ord_1002",
+        assignee: "omar"
+      }
+    }
+  ],
+  runtimeSetup: [
+    "const replyLog: Array<{ replyId: string; ticketId: string; message: string; userId: string }> = [];",
+    "const refundLog: Array<{ refundId: string; orderId: string; amount: number; reason?: string; userId: string }> = [];",
+    "const escalationLog: Array<{ escalationId: string; ticketId: string; queue: string; userId: string }> = [];",
+    "const notificationLog: Array<{ notificationId: string; email: string; subject: string; userId: string }> = [];"
+  ],
+  effects: [
+    {
+      name: "reply",
+      description: "Post a support reply through the external CRM",
+      className: "ticket",
+      inputSchema: {
+        type: "object",
+        properties: {
+          message: { type: "string", description: "Reply body sent to the customer" }
+        },
+        required: ["message"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          replyId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["replyId", "status"]
+      },
+      handlerBody: `const replyId = createId('reply');
+      replyLog.push({
+        replyId,
+        ticketId: objectId,
+        message: input.message,
+        userId: ctx.user.userId,
+      });
+      return {
+        replyId,
+        status: 'sent',
+      };`
+    },
+    {
+      name: "refund",
+      description: "Create a refund in the payment platform",
+      className: "order",
+      inputSchema: {
+        type: "object",
+        properties: {
+          amount: { type: "number", description: "Refund amount in euros" },
+          reason: { type: "string", description: "Reason shown in the payment platform" }
+        },
+        required: ["amount"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          refundId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["refundId", "status"]
+      },
+      handlerBody: `const refundId = createId('refund');
+      refundLog.push({
+        refundId,
+        orderId: objectId,
+        amount: input.amount,
+        reason: input.reason,
+        userId: ctx.user.userId,
+      });
+      return {
+        refundId,
+        status: 'queued',
+      };`
+    },
+    {
+      name: "escalate",
+      description: "Escalate this ticket into another support queue",
+      className: "ticket",
+      inputSchema: {
+        type: "object",
+        properties: {
+          queue: { type: "string", description: "Destination queue name" }
+        },
+        required: ["queue"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          escalationId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["escalationId", "status"]
+      },
+      handlerBody: `const escalationId = createId('escalation');
+      escalationLog.push({
+        escalationId,
+        ticketId: objectId,
+        queue: input.queue,
+        userId: ctx.user.userId,
+      });
+      return {
+        escalationId,
+        status: 'forwarded',
+      };`
+    },
+    {
+      name: "notify_customer",
+      description: "Send a customer notification through the outbound messaging system",
+      inputSchema: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Destination email address" },
+          subject: { type: "string", description: "Notification subject line" },
+          message: { type: "string", description: "Notification body" }
+        },
+        required: ["email", "subject", "message"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          notificationId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["notificationId", "status"]
+      },
+      handlerBody: `const notificationId = createId('notification');
+      notificationLog.push({
+        notificationId,
+        email: input.email,
+        subject: input.subject,
+        userId: ctx.user.userId,
+      });
+      return {
+        notificationId,
+        status: 'queued',
+      };`
+    }
+  ]
+};
+var DELIVERY_TEMPLATE = {
+  id: "delivery",
+  label: "Project Delivery",
+  summary: "A planning graph for clients, projects, milestones, tasks, and delivery actions.",
+  manifestDescription: "A project delivery graph that models clients, projects, milestones, tasks, owners, and external execution actions.",
+  operations: [
+    createClassOperation("client", {
+      name: { type: "string", description: "Client or account name" },
+      industry: { type: "string", description: "Primary industry" },
+      region: { type: "string", description: "Operating region" }
+    }),
+    createClassOperation("project", {
+      name: { type: "string", description: "Project name" },
+      status: { type: "string", description: "Current delivery status" },
+      budget_k_eur: { type: "number", description: "Budget in thousands of euros" }
+    }),
+    createClassOperation("milestone", {
+      name: { type: "string", description: "Milestone title" },
+      due_date: { type: "date", description: "Target due date" },
+      status: { type: "string", description: "Milestone status" }
+    }),
+    createClassOperation("task", {
+      title: { type: "string", description: "Task title" },
+      status: { type: "string", description: "Task execution status" },
+      estimate_days: { type: "number", description: "Estimated effort in days" }
+    }),
+    createClassOperation("owner", {
+      name: { type: "string", description: "Owner full name" },
+      role: { type: "string", description: "Role on the delivery team" },
+      email: { type: "email", description: "Work email address" }
+    }),
+    createRelationshipOperation({
+      left: "client",
+      right: "project",
+      leftSubmodel: "projects",
+      rightSubmodel: "client",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "project",
+      right: "milestone",
+      leftSubmodel: "milestones",
+      rightSubmodel: "project",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "milestone",
+      right: "task",
+      leftSubmodel: "tasks",
+      rightSubmodel: "milestone",
+      leftIsMany: true,
+      rightIsMany: false
+    }),
+    createRelationshipOperation({
+      left: "owner",
+      right: "task",
+      leftSubmodel: "tasks",
+      rightSubmodel: "owner",
+      leftIsMany: true,
+      rightIsMany: false
+    })
+  ],
+  seedUser: {
+    userId: "delivery_demo",
+    name: "Alex Delivery",
+    email: "alex@example.com",
+    permissions: ["default"]
+  },
+  seedRecords: [
+    {
+      className: "client",
+      id: "helios",
+      label: "Helios Energy",
+      fields: {
+        name: "Helios Energy",
+        industry: "Energy",
+        region: "EMEA"
+      }
+    },
+    {
+      className: "owner",
+      id: "lea",
+      label: "Lea Martin",
+      fields: {
+        name: "Lea Martin",
+        role: "Delivery lead",
+        email: "lea@studio.example"
+      }
+    },
+    {
+      className: "owner",
+      id: "sam",
+      label: "Sam Ortega",
+      fields: {
+        name: "Sam Ortega",
+        role: "Product engineer",
+        email: "sam@studio.example"
+      }
+    },
+    {
+      className: "project",
+      id: "helios_portal",
+      label: "Helios Self-Service Portal",
+      fields: {
+        name: "Helios Self-Service Portal",
+        status: "active",
+        budget_k_eur: 180
+      },
+      relationships: {
+        client: "helios"
+      }
+    },
+    {
+      className: "milestone",
+      id: "beta_launch",
+      label: "Beta launch",
+      fields: {
+        name: "Beta launch",
+        due_date: "2026-05-15",
+        status: "planned"
+      },
+      relationships: {
+        project: "helios_portal"
+      }
+    },
+    {
+      className: "milestone",
+      id: "ops_handoff",
+      label: "Operations handoff",
+      fields: {
+        name: "Operations handoff",
+        due_date: "2026-06-10",
+        status: "planned"
+      },
+      relationships: {
+        project: "helios_portal"
+      }
+    },
+    {
+      className: "task",
+      id: "task_auth_flow",
+      label: "Auth flow",
+      fields: {
+        title: "Finalize auth flow",
+        status: "in_progress",
+        estimate_days: 4
+      },
+      relationships: {
+        milestone: "beta_launch",
+        owner: "sam"
+      }
+    },
+    {
+      className: "task",
+      id: "task_status_report",
+      label: "Status report",
+      fields: {
+        title: "Prepare weekly status report",
+        status: "todo",
+        estimate_days: 1
+      },
+      relationships: {
+        milestone: "ops_handoff",
+        owner: "lea"
+      }
+    }
+  ],
+  runtimeSetup: [
+    "const issueLog: Array<{ issueId: string; taskId: string; title: string; userId: string }> = [];",
+    "const releaseLog: Array<{ releaseId: string; projectId: string; environment: string; userId: string }> = [];",
+    "const reportLog: Array<{ reportId: string; email: string; projectId: string; userId: string }> = [];",
+    "const pingLog: Array<{ pingId: string; ownerId: string; channel: string; userId: string }> = [];"
+  ],
+  effects: [
+    {
+      name: "create_issue",
+      description: "Create a delivery issue in the external tracker",
+      className: "task",
+      inputSchema: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Issue title" },
+          description: { type: "string", description: "Issue details" }
+        },
+        required: ["title"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          issueId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["issueId", "status"]
+      },
+      handlerBody: `const issueId = createId('issue');
+      issueLog.push({
+        issueId,
+        taskId: objectId,
+        title: input.title,
+        userId: ctx.user.userId,
+      });
+      return {
+        issueId,
+        status: 'created',
+      };`
+    },
+    {
+      name: "schedule_release",
+      description: "Schedule a deployment for this project in the release system",
+      className: "project",
+      inputSchema: {
+        type: "object",
+        properties: {
+          environment: { type: "string", description: "Target environment such as staging or production" }
+        },
+        required: ["environment"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          releaseId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["releaseId", "status"]
+      },
+      handlerBody: `const releaseId = createId('release');
+      releaseLog.push({
+        releaseId,
+        projectId: objectId,
+        environment: input.environment,
+        userId: ctx.user.userId,
+      });
+      return {
+        releaseId,
+        status: 'scheduled',
+      };`
+    },
+    {
+      name: "ping",
+      description: "Send a follow-up to the owner in an external messaging channel",
+      className: "owner",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "Destination channel such as slack or email" },
+          message: { type: "string", description: "Message body" }
+        },
+        required: ["channel", "message"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          pingId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["pingId", "status"]
+      },
+      handlerBody: `const pingId = createId('ping');
+      pingLog.push({
+        pingId,
+        ownerId: objectId,
+        channel: input.channel,
+        userId: ctx.user.userId,
+      });
+      return {
+        pingId,
+        status: 'sent',
+      };`
+    },
+    {
+      name: "send_status_report",
+      description: "Send a status report to stakeholders through an external workflow",
+      inputSchema: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Destination email address" },
+          projectId: { type: "string", description: "Project referenced by the report" },
+          summary: { type: "string", description: "Status report summary" }
+        },
+        required: ["email", "projectId", "summary"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          reportId: { type: "string" },
+          status: { type: "string" }
+        },
+        required: ["reportId", "status"]
+      },
+      handlerBody: `const reportId = createId('report');
+      reportLog.push({
+        reportId,
+        email: input.email,
+        projectId: input.projectId,
+        userId: ctx.user.userId,
+      });
+      return {
+        reportId,
+        status: 'queued',
+      };`
+    }
+  ]
+};
+var STARTER_TEMPLATES = {
+  library: LIBRARY_TEMPLATE,
+  support: SUPPORT_TEMPLATE,
+  delivery: DELIVERY_TEMPLATE
+};
+function toWsUrl(apiUrl) {
+  return apiUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+}
+function formatValue(value) {
+  return JSON.stringify(value, null, 2);
+}
+function indent(text, spaces) {
+  const pad = " ".repeat(spaces);
+  return text.split("\n").map((line) => line.length > 0 ? `${pad}${line}` : line).join("\n");
+}
+function renderEffectRegistration(effect) {
+  const staticLine = effect.static ? "\n      static: true," : "";
+  const classLine = effect.className ? `
+      className: '${effect.className}',` : "";
+  const inputSchema = indent(formatValue(effect.inputSchema), 6);
+  const outputSchema = indent(formatValue(effect.outputSchema), 6);
+  const handlerSignature = effect.className && !effect.static ? "async (objectId: string, input: any, ctx: any) =>" : "async (input: any, ctx: any) =>";
+  return `    {
+      name: '${effect.name}',
+      description: ${JSON.stringify(effect.description)},${classLine}${staticLine}
+      inputSchema: ${inputSchema.trimStart()},
+      outputSchema: ${outputSchema.trimStart()},
+      handler: ${handlerSignature} {
+${indent(effect.handlerBody, 8)}
+      },
+    }`;
+}
+function listStarterTemplates() {
+  return Object.values(STARTER_TEMPLATES);
+}
+function isStarterTemplateId(value) {
+  return value in STARTER_TEMPLATES;
+}
+function getStarterTemplate(templateId) {
+  return STARTER_TEMPLATES[templateId || DEFAULT_STARTER_TEMPLATE_ID];
+}
+function createStarterManifest(name, templateId) {
+  const template = getStarterTemplate(templateId);
+  return {
+    schemaVersion: 2,
+    name,
+    description: `${name} \u2014 ${template.manifestDescription}`,
+    volumes: [{
+      name: "schema",
+      scope: "sandbox",
+      imports: [
+        { alias: "@std", name: "standard_modules", label: "prod" }
+      ],
+      operations: [
+        ...template.operations,
+        ...template.effects.map(createEffectOperation)
+      ]
+    }]
+  };
+}
+function generateSeedScript(sandboxId, apiUrl, templateId) {
+  const template = getStarterTemplate(templateId);
+  const wsUrl = toWsUrl(apiUrl);
+  const recordsLiteral = indent(formatValue(template.seedRecords), 2);
+  return `/**
+ * Seed script for the "${template.label}" starter template.
+ *
+ * Safe to re-run:
+ * - \`recordObject()\` upserts by \`{ className, id }\`
+ * - relationships are re-applied on each run
+ */
+
+import { Granular } from '@granular-software/sdk';
+
+const SANDBOX_ID = '${sandboxId}';
+const API_URL = '${wsUrl}';
+
+function requireApiKey(): string {
+  const apiKey = process.env.GRANULAR_API_KEY;
+  if (!apiKey) {
+    throw new Error('Set GRANULAR_API_KEY in .env.local or in your shell before running this script.');
+  }
+  return apiKey;
+}
+
+const records = ${recordsLiteral.trimStart()};
+
+async function main() {
+  const granular = new Granular({
+    apiKey: requireApiKey(),
+    apiUrl: process.env.GRANULAR_API_URL ?? API_URL,
+  });
+
+  // Connect as one app user so the SDK can create an environment for the seed run.
+  const env = await granular.connect({
+    sandbox: SANDBOX_ID,
+    userId: '${template.seedUser.userId}',
+    name: '${template.seedUser.name}',
+    email: '${template.seedUser.email}',
+    permissions: ${formatValue(template.seedUser.permissions)},
+  });
+
+  try {
+    for (const record of records) {
+      await env.recordObject(record);
+      console.log(\`Upserted \${record.className}:\${record.id}\`);
+    }
+  } finally {
+    await env.disconnect();
+  }
+
+  console.log(\`Seeded \${records.length} records into \${SANDBOX_ID}\`);
+}
+
+main().catch((error) => {
+  console.error('[Seed] Failed:', error);
+  process.exit(1);
+});
+`;
+}
+function generateEffectsScript(sandboxId, apiUrl, templateId) {
+  const template = getStarterTemplate(templateId);
+  const wsUrl = toWsUrl(apiUrl);
+  const runtimeSetup = template.runtimeSetup.map((line) => `${line}`).join("\n");
+  const registrations = template.effects.map(renderEffectRegistration).join(",\n");
+  return `/**
+ * Live effect host for the "${template.label}" starter template.
+ *
+ * These handlers simulate calls to external systems such as checkout, CRM,
+ * messaging, or release tooling. Replace the stub bodies with your real APIs.
+ */
+
+import { Granular } from '@granular-software/sdk';
+
+const SANDBOX_ID = '${sandboxId}';
+const API_URL = '${wsUrl}';
+
+${runtimeSetup}
+
+function requireApiKey(): string {
+  const apiKey = process.env.GRANULAR_API_KEY;
+  if (!apiKey) {
+    throw new Error('Set GRANULAR_API_KEY in .env.local or in your shell before running this script.');
+  }
+  return apiKey;
+}
+
+function createId(prefix: string): string {
+  return \`\${prefix}_\${Math.random().toString(36).slice(2, 10)}\`;
+}
+
+async function main() {
+  const granular = new Granular({
+    apiKey: requireApiKey(),
+    apiUrl: process.env.GRANULAR_API_URL ?? API_URL,
+  });
+
+  await granular.registerEffects(SANDBOX_ID, [
+${registrations}
+  ]);
+
+  console.log(\`Effect host connected for \${SANDBOX_ID}\`);
+  console.log('Handlers are live. Press Ctrl+C to disconnect.');
+
+  // Keep one active timer so Node or Bun does not exit while the host is serving effects.
+  const keepAliveTimer = setInterval(() => {}, 60_000);
+
+  await new Promise<void>((resolve) => {
+    let shuttingDown = false;
+
+    const shutdown = async (signal: string) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      clearInterval(keepAliveTimer);
+      console.log(\`Shutting down after \${signal}...\`);
+      await granular.disconnectEffects(SANDBOX_ID);
+      resolve();
+      process.exit(0);
+    };
+
+    process.once('SIGINT', () => { void shutdown('SIGINT'); });
+    process.once('SIGTERM', () => { void shutdown('SIGTERM'); });
+  });
+}
+
+main().catch((error) => {
+  console.error('[Effects] Failed:', error);
+  process.exit(1);
+});
+`;
+}
+
 // src/cli/config.ts
 var MANIFEST_FILE = "granular.json";
 var RC_FILE = ".granularrc";
@@ -5552,162 +6728,11 @@ function ensureGitignore() {
     fs__namespace.writeFileSync(gitignorePath, content + section, "utf-8");
   }
 }
-function createDefaultEffectOperations(classNames) {
-  const operations = classNames.flatMap((className) => {
-    const searchName = `search_${className}s`;
-    return [
-      {
-        withEffect: {
-          name: "get_info",
-          description: `Get details of a ${className} by ID`,
-          attachedClass: className,
-          isStatic: false,
-          inputSchema: {
-            type: "object",
-            properties: {
-              include_related: { type: "boolean", description: "Include related items" }
-            }
-          },
-          outputSchema: {
-            type: "object",
-            properties: {
-              id: { type: "string" },
-              name: { type: "string" },
-              related: { type: "array", items: { type: "object" } }
-            }
-          }
-        }
-      },
-      {
-        withEffect: {
-          name: searchName,
-          description: `Search ${className}s by keyword`,
-          attachedClass: className,
-          isStatic: true,
-          inputSchema: {
-            type: "object",
-            properties: {
-              query: { type: "string", description: "Search keyword" },
-              limit: { type: "number", description: "Max results" }
-            },
-            required: ["query"]
-          },
-          outputSchema: {
-            type: "object",
-            properties: {
-              query: { type: "string" },
-              results: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    id: { type: "string" },
-                    name: { type: "string" }
-                  }
-                }
-              },
-              total: { type: "number" }
-            }
-          }
-        }
-      }
-    ];
-  });
-  operations.push({
-    withEffect: {
-      name: "full_text_search",
-      description: "Search across all types",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          types: { type: "array", items: { type: "string" }, description: "Filter by type" }
-        },
-        required: ["query"]
-      },
-      outputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string" },
-          types: { type: "array", items: { type: "string" } },
-          matches: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                type: { type: "string" },
-                id: { type: "string" },
-                label: { type: "string" },
-                snippet: { type: "string" }
-              }
-            }
-          },
-          total: { type: "number" }
-        }
-      }
-    }
-  });
-  return operations;
-}
-function createDefaultManifest(name) {
-  const classNames = ["note", "tag"];
+function createDefaultManifest(name, templateId = DEFAULT_STARTER_TEMPLATE_ID) {
   return {
-    manifest: {
-      schemaVersion: 2,
-      name,
-      description: `${name} \u2014 built with Granular`,
-      volumes: [{
-        name: "schema",
-        scope: "sandbox",
-        imports: [
-          { alias: "@std", name: "standard_modules", label: "prod" }
-        ],
-        operations: [
-          {
-            create: "note",
-            extends: "@std/class",
-            has: {
-              title: { type: "string", description: "Note title" },
-              content: { type: "string", description: "Note content" },
-              priority: { type: "number", description: "Priority level (1-5)" }
-            }
-          },
-          {
-            create: "tag",
-            extends: "@std/class",
-            has: {
-              name: { type: "string", description: "Tag name" },
-              color: { type: "string", description: "Tag color hex code" }
-            }
-          },
-          {
-            defineRelationship: {
-              left: "note",
-              right: "tag",
-              leftSubmodel: "tags",
-              rightSubmodel: "notes",
-              leftIsMany: true,
-              rightIsMany: true
-            }
-          },
-          ...createDefaultEffectOperations(classNames)
-        ]
-      }]
-    }
+    manifest: createStarterManifest(name, templateId)
   };
 }
-var STD_CLASS_NAMES = /* @__PURE__ */ new Set(["entity", "class", "user", "company", "string", "number", "boolean", "tool_parameter"]);
-function getClassNamesFromManifest(manifest) {
-  const names = /* @__PURE__ */ new Set();
-  for (const vol of manifest.volumes ?? []) {
-    for (const op of vol.operations ?? []) {
-      if (op.create && !STD_CLASS_NAMES.has(op.create)) {
-        names.add(op.create);
-      }
-    }
-  }
-  return Array.from(names);
-}
 function resolveConfig(options) {
   const apiKey = loadApiKey();
   const apiUrl = loadApiUrl();
@@ -7310,11 +8335,11 @@ var Ora = class {
   get indent() {
     return this.#indent;
   }
-  set indent(indent = 0) {
-    if (!(indent >= 0 && Number.isInteger(indent))) {
+  set indent(indent2 = 0) {
+    if (!(indent2 >= 0 && Number.isInteger(indent2))) {
       throw new Error("The `indent` option must be an integer from 0 and up");
     }
-    this.#indent = indent;
+    this.#indent = indent2;
     this.#updateLineCount();
   }
   get interval() {
@@ -7636,174 +8661,6 @@ function buildStatus(status) {
 }
 
 // src/cli/commands/init.ts
-var EFFECTS_SCRIPT_NAME = "granular-effects.ts";
-function toWsUrl(apiUrl) {
-  return apiUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
-}
-function generateEffectsScript(sandboxId, apiUrl, classNames) {
-  const wsUrl = toWsUrl(apiUrl);
-  classNames.length > 0;
-  const mockDataEntries = classNames.map(
-    (c) => `        ${c}: [
-            { id: '${c}_001', name: 'Sample ${c}' },
-            { id: '${c}_002', name: 'Another ${c}' },
-        ]`
-  );
-  const mockDataBlock = mockDataEntries.length > 0 ? `const MOCK_DATA: Record<string, any[]> = {
-${mockDataEntries.join(",\n")},
-    };` : "const MOCK_DATA: Record<string, any[]> = {};";
-  const instanceEffects = classNames.map((className) => {
-    className.charAt(0).toUpperCase() + className.slice(1);
-    return `        {
-            name: 'get_info',
-            description: \`Get details of a ${className} by ID\`,
-            className: '${className}',
-            inputSchema: {
-                type: 'object',
-                properties: { include_related: { type: 'boolean', description: 'Include related items' } },
-            },
-            handler: async (id: string, params: any) => {
-                logEffect('get_info', '${className}', id, params);
-                const item = (MOCK_DATA['${className}'] || []).find((x: any) => x.id === id);
-                if (!item) return { error: \`${className} "\${id}" not found\` };
-                return { ...item, ...(params?.include_related ? { related: [] } : {}) };
-            },
-        }`;
-  });
-  const staticEffects = classNames.map((className) => {
-    const searchName = "search_" + className + "s";
-    return `        {
-            name: '${searchName}',
-            description: \`Search ${className}s by keyword\`,
-            className: '${className}',
-            static: true,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'Search keyword' },
-                    limit: { type: 'number', description: 'Max results' },
-                },
-                required: ['query'],
-            },
-            handler: async (params: any) => {
-                logEffect('${searchName}', null, null, params);
-                const q = ((params?.query) || '').toLowerCase();
-                const limit = params?.limit ?? 10;
-                const list = (MOCK_DATA['${className}'] || []).filter((x: any) =>
-                    String(x.name || x.id || '').toLowerCase().includes(q)
-                ).slice(0, limit);
-                return { query: params?.query, results: list, total: list.length };
-            },
-        }`;
-  });
-  const allEffects = [...instanceEffects, ...staticEffects];
-  if (allEffects.length > 0) {
-    allEffects.push(`        {
-            name: 'full_text_search',
-            description: 'Search across all types',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'Search query' },
-                    types: { type: 'array', items: { type: 'string' }, description: 'Filter by type' },
-                },
-                required: ['query'],
-            },
-            handler: async (params: any) => {
-                logEffect('full_text_search', null, null, params);
-                const q = ((params?.query) || '').toLowerCase();
-                const types: string[] = params?.types || [${classNames.map((c) => `'${c}'`).join(", ")}];
-                const matches: any[] = [];
-                for (const type of types) {
-                    const items = MOCK_DATA[type] || [];
-                    for (const item of items) {
-                        const text = Object.values(item).join(' ').toLowerCase();
-                        if (!q || text.includes(q)) {
-                            matches.push({ type, id: item.id, label: item.name || item.id, snippet: text.slice(0, 60) });
-                        }
-                    }
-                }
-                return { query: params?.query, types, matches, total: matches.length };
-            },
-        }`);
-  }
-  const effectsArray = allEffects.length > 0 ? `[
-${allEffects.join(",\n")}
-    ]` : "[]";
-  return `/**
- * Granular effects script for sandbox ${sandboxId}
- * Run with: npx tsx ${EFFECTS_SCRIPT_NAME}
- * Requires: GRANULAR_API_KEY in env or .env.local, and optional "ws" package for Node.
- *
- * Keeps the process alive so the simulator can invoke these effect handlers.
- */
-
-import { Granular } from '@granular-software/sdk';
-
-const SANDBOX_ID = '${sandboxId}';
-const API_URL = '${wsUrl}';
-
-function log(msg: string) {
-    console.log(\`[\${new Date().toISOString()}] [Effects] \${msg}\`);
-}
-
-function logEffect(name: string, className: string | null, id: string | null, params: any) {
-    const target = className ? (id ? \`\${className}(\${id})\` : \`\${className}\`) : 'global';
-    console.log(\`  [EFFECT] \${name}(\${target}) \${JSON.stringify(params || {})}\`);
-}
-
-async function main() {
-    const auth = process.env.GRANULAR_TOKEN ?? process.env.GRANULAR_API_KEY;
-    if (!auth) {
-        console.error('[Effects] Set GRANULAR_API_KEY or GRANULAR_TOKEN (e.g. from simulator "Copy CLI env").');
-        process.exit(1);
-    }
-
-    log('Initializing client...');
-    const granular = new Granular({
-        ...(auth.startsWith('eyJ') ? { token: auth } : { apiKey: auth }),
-        apiUrl: process.env.GRANULAR_API_URL ?? API_URL,
-    });
-
-    log(\`Registering live effects for sandbox \${SANDBOX_ID}\`);
-    ${mockDataBlock}
-
-    await granular.registerEffects(SANDBOX_ID, ${effectsArray});
-
-    log('Effects registered. Process kept alive for simulator. Press Ctrl+C to exit.');
-
-    const keepAliveTimer = setInterval(() => {
-        // Keep an active event-loop handle so Bun/Node does not exit immediately.
-    }, 60_000);
-
-    await new Promise<void>((resolve) => {
-        let shuttingDown = false;
-
-        const shutdown = async (signal: string) => {
-            if (shuttingDown) return;
-            shuttingDown = true;
-            clearInterval(keepAliveTimer);
-            log(\`Received \${signal}. Shutting down effects host...\`);
-            try {
-                await granular.disconnectEffects(SANDBOX_ID);
-            } catch (error) {
-                console.warn('[Effects] Failed to disconnect live effects cleanly:', error);
-            }
-            resolve();
-            process.exit(0);
-        };
-
-        process.once('SIGINT', () => { void shutdown('SIGINT'); });
-        process.once('SIGTERM', () => { void shutdown('SIGTERM'); });
-    });
-}
-
-main().catch((err) => {
-    console.error('[Effects] Failed:', err);
-    process.exit(1);
-});
-`;
-}
 function prompt(question, defaultValue) {
   const rl = readline__namespace.createInterface({ input: process.stdin, output: process.stdout });
   const suffix = defaultValue ? ` ${brand.muted(`(${defaultValue})`)}` : "";
@@ -7833,6 +8690,40 @@ function confirm(question, defaultYes = true) {
     return answer.toLowerCase().startsWith("y");
   });
 }
+async function selectStarterTemplate(requestedTemplate) {
+  if (requestedTemplate) {
+    if (!isStarterTemplateId(requestedTemplate)) {
+      throw new Error(
+        `Unknown template "${requestedTemplate}". Use one of: ${listStarterTemplates().map((template) => template.id).join(", ")}.`
+      );
+    }
+    return requestedTemplate;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return DEFAULT_STARTER_TEMPLATE_ID;
+  }
+  const templates = listStarterTemplates();
+  const defaultIndex = templates.findIndex((template) => template.id === DEFAULT_STARTER_TEMPLATE_ID);
+  step("Choose a starter ontology template");
+  for (const [index, template] of templates.entries()) {
+    const isDefault = template.id === DEFAULT_STARTER_TEMPLATE_ID;
+    const defaultLabel = isDefault ? ` ${brand.muted("(default)")}` : "";
+    console.log(`  ${index + 1}. ${brand.bold(template.label)}${defaultLabel}`);
+    dim(`     ${template.id} \u2014 ${template.summary}`);
+  }
+  console.log();
+  const rawChoice = await prompt("Template", String(defaultIndex + 1));
+  const normalizedChoice = rawChoice.trim().toLowerCase();
+  const byNumber = Number.parseInt(normalizedChoice, 10);
+  if (Number.isFinite(byNumber) && byNumber >= 1 && byNumber <= templates.length) {
+    return templates[byNumber - 1].id;
+  }
+  if (isStarterTemplateId(normalizedChoice)) {
+    return normalizedChoice;
+  }
+  warn(`Unknown template "${rawChoice}". Falling back to ${DEFAULT_STARTER_TEMPLATE_ID}.`);
+  return DEFAULT_STARTER_TEMPLATE_ID;
+}
 async function initCommand(projectName, options) {
   printHeader();
   if (manifestExists()) {
@@ -7886,6 +8777,9 @@ async function initCommand(projectName, options) {
   dim("Saved to .env.local");
   const dirName = path__namespace.basename(process.cwd());
   const name = projectName || await prompt("Project name", dirName);
+  const templateId = await selectStarterTemplate(options?.template);
+  const template = getStarterTemplate(templateId);
+  info(`Using template: ${template.label}`);
   console.log();
   const creating = spinner(`Creating sandbox "${name}"...`);
   let sandbox;
@@ -7898,9 +8792,9 @@ async function initCommand(projectName, options) {
     creating.fail(`  Failed to create sandbox: ${err.message}`);
     process.exit(1);
   }
-  const project = createDefaultManifest(name);
+  const project = createDefaultManifest(name, templateId);
   writeManifestFile(project);
-  success(`Created ${brand.bold("granular.json")} with starter manifest`);
+  success(`Created ${brand.bold("granular.json")} with the ${template.label} starter ontology`);
   writeRcFile({
     sandboxId: sandbox.sandboxId,
     sandboxName: sandbox.name,
@@ -7932,11 +8826,20 @@ async function initCommand(projectName, options) {
       dim("You can retry with `granular build`");
     }
   }
-  const classNames = getClassNamesFromManifest(project.manifest);
   const effectsPath = path__namespace.join(getProjectRoot(), EFFECTS_SCRIPT_NAME);
-  const effectsContent = generateEffectsScript(sandbox.sandboxId, apiUrl, classNames);
-  fs__namespace.writeFileSync(effectsPath, effectsContent, "utf-8");
-  success(`Created ${brand.bold(EFFECTS_SCRIPT_NAME)} (effects script for simulator)`);
+  const seedPath = path__namespace.join(getProjectRoot(), SEED_SCRIPT_NAME);
+  fs__namespace.writeFileSync(
+    effectsPath,
+    generateEffectsScript(sandbox.sandboxId, apiUrl, templateId),
+    "utf-8"
+  );
+  success(`Created ${brand.bold(EFFECTS_SCRIPT_NAME)} (external effect host)`);
+  fs__namespace.writeFileSync(
+    seedPath,
+    generateSeedScript(sandbox.sandboxId, apiUrl, templateId),
+    "utf-8"
+  );
+  success(`Created ${brand.bold(SEED_SCRIPT_NAME)} (sample record seeding script)`);
   console.log();
   divider();
   console.log();
@@ -7944,21 +8847,29 @@ async function initCommand(projectName, options) {
   console.log();
   keyValue({
     "Sandbox": sandbox.sandboxId,
+    "Template": template.label,
     "Manifest": "granular.json",
     "Config": ".granularrc",
     "API Key": ".env.local",
+    "Seed script": SEED_SCRIPT_NAME,
     "Effects script": EFFECTS_SCRIPT_NAME
   });
-  nextSteps([
-    { command: "granular add class <name>", description: "Add a class to your schema" },
-    { command: "granular build", description: "Build your sandbox" },
-    { command: "granular status", description: "Check build status" }
-  ]);
+  const nextSteps2 = options?.skipBuild ? [
+    { command: "granular build", description: "Build the starter ontology before you seed or simulate" },
+    { command: `npx tsx ${SEED_SCRIPT_NAME}`, description: "Push the sample records into your sandbox" },
+    { command: `npx tsx ${EFFECTS_SCRIPT_NAME}`, description: "Connect live handlers for the declared external actions" },
+    { command: "granular simulate", description: "Open the simulator for this sandbox" }
+  ] : [
+    { command: `npx tsx ${SEED_SCRIPT_NAME}`, description: "Push the sample records into your sandbox" },
+    { command: `npx tsx ${EFFECTS_SCRIPT_NAME}`, description: "Connect live handlers for the declared external actions" },
+    { command: "granular simulate", description: "Open the simulator for this sandbox" },
+    { command: "granular add class <name>", description: "Extend the ontology once the starter model is clear" }
+  ];
+  nextSteps(nextSteps2);
   console.log();
-  dim("Run the effects script (keeps process alive for simulator):");
-  hint(`npx tsx ${EFFECTS_SCRIPT_NAME}`, "requires tsx and GRANULAR_API_KEY in .env.local");
-  dim("Open the simulator in your browser:");
-  hint("granular simulate", "opens app.granular.software/simulator for this sandbox");
+  dim("Mental model:");
+  dim("  Query and navigate data through the ontology. Use effects only for actions that leave the sandbox.");
+  dim("  The seed script shows how records enter the graph. The effects script shows how external systems plug in.");
   console.log();
 }
 var DEFAULT_LOCAL_API_KEY = "gn_sk_tenant_default_principal_local_e2e_00000000";
@@ -8619,7 +9530,7 @@ ${manifest.description}`);
   lines.push(`import { Granular } from '@granular-software/sdk';`);
   lines.push(`
 const granular = new Granular({`);
-  lines.push(`  ...(process.env.GRANULAR_TOKEN ? { token: process.env.GRANULAR_TOKEN } : { apiKey: process.env.GRANULAR_API_KEY! }),`);
+  lines.push(`  apiKey: process.env.GRANULAR_API_KEY!,`);
   lines.push(`});`);
   lines.push(`
 // 1. Connect to the sandbox for one of your app users`);
@@ -8678,7 +9589,7 @@ console.log('Connected to:', env.environmentId);`);
   }
   lines.push(`
 ### 3. Declare And Register Effects`);
-  lines.push(`Declare effects in your manifest with \`withEffect\`, then register live handlers at sandbox scope.`);
+  lines.push(`Declare effects in your manifest with \`withEffect\`, then register live handlers at sandbox scope. Use effects for actions in external systems, not for graph reads or search.`);
   lines.push(`
 \`\`\`typescript`);
   lines.push(`await granular.registerEffects('your-sandbox-id', [`);
@@ -8686,35 +9597,22 @@ console.log('Connected to:', env.environmentId);`);
     const cls = classes[0];
     lines.push(`  // Instance method on ${cls.name}`);
     lines.push(`  {`);
-    lines.push(`    name: 'summarize',`);
-    lines.push(`    description: 'Summarize this ${cls.name}',`);
+    lines.push(`    name: 'sync_external_action',`);
+    lines.push(`    description: 'Perform an external action for this ${cls.name}',`);
     lines.push(`    className: '${cls.name}',`);
-    lines.push(`    inputSchema: { type: 'object', properties: { maxLength: { type: 'number' } } },`);
-    lines.push(`    outputSchema: { type: 'object', properties: { summary: { type: 'string' } }, required: ['summary'] },`);
+    lines.push(`    inputSchema: { type: 'object', properties: { reason: { type: 'string' } } },`);
+    lines.push(`    outputSchema: { type: 'object', properties: { actionId: { type: 'string' }, status: { type: 'string' } }, required: ['actionId', 'status'] },`);
     lines.push(`    handler: async (id, params, ctx) => {`);
     lines.push(`      // 'id' is the real-world ID of the ${cls.name}`);
     lines.push(`      console.log('Invoked for user', ctx.user.subjectId);`);
-    lines.push(`      return { summary: \`Summary for \${id}\` };`);
-    lines.push(`    },`);
-    lines.push(`  },`);
-    lines.push(`  // Static method on ${cls.name}`);
-    lines.push(`  {`);
-    lines.push(`    name: 'search',`);
-    lines.push(`    description: 'Search ${cls.name}s',`);
-    lines.push(`    className: '${cls.name}',`);
-    lines.push(`    static: true,`);
-    lines.push(`    inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },`);
-    lines.push(`    outputSchema: { type: 'object', properties: { ids: { type: 'array' } }, required: ['ids'] },`);
-    lines.push(`    handler: async (params, ctx) => {`);
-    lines.push(`      console.log('Invoked for user', ctx.user.subjectId);`);
-    lines.push(`      return { ids: [] };`);
+    lines.push(`      return { actionId: \`act_\${id}\`, status: 'queued' };`);
     lines.push(`    },`);
     lines.push(`  },`);
   }
   lines.push(`  // Global effect`);
   lines.push(`  {`);
-  lines.push(`    name: 'notify',`);
-  lines.push(`    description: 'Send notification',`);
+  lines.push(`    name: 'notify_team',`);
+  lines.push(`    description: 'Send a message through an external workflow',`);
   lines.push(`    inputSchema: { type: 'object', properties: { msg: { type: 'string' } }, required: ['msg'] },`);
   lines.push(`    handler: async (params, ctx) => {`);
   lines.push(`      console.log('Invoked for user', ctx.user.subjectId);`);
@@ -8731,9 +9629,9 @@ console.log('Connected to:', env.environmentId);`);
   lines.push(`const job = await env.submitJob(\``);
   const classImports = classes.map((c) => c.name.charAt(0).toUpperCase() + c.name.slice(1)).join(", ");
   if (classImports) {
-    lines.push(`  import { ${classImports}, notify } from './sandbox-tools';`);
+    lines.push(`  import { ${classImports}, notify_team } from './sandbox-tools';`);
   } else {
-    lines.push(`  import { notify } from './sandbox-tools';`);
+    lines.push(`  import { notify_team } from './sandbox-tools';`);
   }
   lines.push(``);
   if (classes.length > 0) {
@@ -8746,16 +9644,13 @@ console.log('Connected to:', env.environmentId);`);
     lines.push(``);
     lines.push(`  // 2. Call instance method`);
     lines.push(`  if (item) {`);
-    lines.push(`    const summary = await item.summarize({ maxLength: 100 });`);
-    lines.push(`    console.log(summary);`);
+    lines.push(`    const action = await item.sync_external_action({ reason: 'Example workflow' });`);
+    lines.push(`    console.log(action);`);
     lines.push(`  }`);
     lines.push(``);
-    lines.push(`  // 3. Call static method`);
-    lines.push(`  const results = await ${ClassName}.search({ query: 'test' });`);
-    lines.push(``);
   }
   lines.push(`  // Call global tool`);
-  lines.push(`  await notify({ msg: 'Job completed' });`);
+  lines.push(`  await notify_team({ msg: 'Job completed' });`);
   lines.push(``);
   lines.push(`  return { success: true };`);
   lines.push(`\`);`);
@@ -8817,9 +9712,12 @@ program2.hook("preAction", () => {
     process.env.GRANULAR_ENDPOINT_MODE = mode;
   }
 });
-program2.command("init [project-name]").description("Initialize a new Granular project").option("--skip-build", "Skip the initial build step").action(async (projectName, opts) => {
+program2.command("init [project-name]").description("Initialize a new Granular project").option("--skip-build", "Skip the initial build step").option("--template <template>", "Starter ontology template: library|support|delivery").action(async (projectName, opts) => {
   try {
-    await initCommand(projectName, { skipBuild: opts.skipBuild });
+    await initCommand(projectName, {
+      skipBuild: opts.skipBuild,
+      template: opts.template
+    });
   } catch (err) {
     error(err.message);
     process.exit(1);