startup-builder 0.2.0 → 0.3.0

package/dist/chunk-NWM7TYW6.js

@@ -1,1004 +0,0 @@
-// src/machines/startup-builder.ts
-import { setup, assign } from "xstate";
-import {
-  icpSchema,
-  competitorSchema,
-  leanCanvasSchema,
-  hypothesisSchema,
-  differentiatorSchema,
-  storyBrandSchema,
-  agentSchema
-} from "startups.studio/schemas";
-var startupBuilderMachine = setup({
-  types: {
-    context: {},
-    events: {},
-    input: {}
-  },
-  guards: {
-    hasResearchArtifacts: ({ context }) => context.icpCount >= 1 && context.competitorCount >= 1,
-    hasCanvasArtifacts: ({ context }) => context.leanCanvasCount >= 1 && context.hypothesisCount >= 1,
-    hasPositioningArtifacts: ({ context }) => context.positioningSet && context.differentiatorCount >= 1,
-    hasMessagingArtifacts: ({ context }) => context.storyBrandCount >= 1,
-    hasServicesComplete: ({ context }) => context.serviceCount >= 1,
-    hasTeamArtifacts: ({ context }) => context.agentCount >= 1,
-    hasSiteComplete: ({ context }) => context.domainCount >= 1 && context.pageCount >= 1,
-    isSkipping: ({ event }) => event.type === "SKIP"
-  },
-  actions: {
-    recordSkip: assign({
-      skipReason: ({ event }) => event.type === "SKIP" ? event.reason : void 0
-    }),
-    updateArtifactCount: assign(({ context, event }) => {
-      if (event.type !== "ARTIFACT_CREATED") return context;
-      const map = {
-        icps: "icpCount",
-        competitors: "competitorCount",
-        "lean-canvases": "leanCanvasCount",
-        hypotheses: "hypothesisCount",
-        differentiators: "differentiatorCount",
-        "story-brands": "storyBrandCount",
-        services: "serviceCount",
-        agents: "agentCount",
-        domains: "domainCount",
-        pages: "pageCount"
-      };
-      const key = map[event.collection];
-      if (!key) return context;
-      return { ...context, [key]: event.count };
-    }),
-    setPositioning: assign({ positioningSet: true }),
-    setResult: assign(({ event }) => ({
-      result: event.type === "SALES_COMPLETE" ? event.result : void 0
-    }))
-  }
-}).createMachine({
-  id: "startup-builder",
-  initial: "research",
-  context: ({ input }) => ({
-    startupId: input.startupId,
-    ideaId: input.ideaId,
-    sprintId: input.sprintId,
-    icpCount: 0,
-    competitorCount: 0,
-    leanCanvasCount: 0,
-    hypothesisCount: 0,
-    positioningSet: false,
-    differentiatorCount: 0,
-    storyBrandCount: 0,
-    serviceCount: 0,
-    agentCount: 0,
-    domainCount: 0,
-    pageCount: 0
-  }),
-  on: {
-    ARTIFACT_CREATED: { actions: "updateArtifactCount" }
-  },
-  states: {
-    research: {
-      description: "Define who you are building for and who you are competing with",
-      meta: {
-        requiredArtifacts: {
-          icps: { min: 1, description: "Ideal Customer Profiles" },
-          competitors: { min: 1, description: "Competitor analyses" }
-        },
-        commands: [
-          {
-            name: "Create ICP",
-            collection: "icps",
-            schema: icpSchema
-          },
-          {
-            name: "Create Competitor",
-            collection: "competitors",
-            schema: competitorSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasResearchArtifacts", target: "canvas" },
-        SKIP: { target: "canvas", actions: "recordSkip" }
-      }
-    },
-    canvas: {
-      description: "Formulate your hypothesis and business model",
-      meta: {
-        requiredArtifacts: {
-          "lean-canvases": { min: 1, description: "Lean Canvas" },
-          hypotheses: { min: 1, description: "Testable hypotheses" }
-        },
-        commands: [
-          {
-            name: "Create Lean Canvas",
-            collection: "lean-canvases",
-            schema: leanCanvasSchema
-          },
-          {
-            name: "Create Hypothesis",
-            collection: "hypotheses",
-            schema: hypothesisSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasCanvasArtifacts", target: "positioning" },
-        SKIP: { target: "positioning", actions: "recordSkip" }
-      }
-    },
-    positioning: {
-      description: "Define where you sit in the market",
-      meta: {
-        requiredArtifacts: {
-          positioning: { min: 1, description: "Positioning data on startup" },
-          differentiators: { min: 1, description: "Key differentiators" }
-        },
-        commands: [
-          {
-            name: "Set Positioning",
-            collection: "startups",
-            operation: "update",
-            schema: {
-              positioning: {
-                xAxis: "Label for horizontal axis (e.g. Generic to Specialized)",
-                yAxis: "Label for vertical axis (e.g. Manual to Automated)",
-                placements: [
-                  {
-                    name: "Company name",
-                    x: "number: 0-100 position on x axis",
-                    y: "number: 0-100 position on y axis"
-                  }
-                ]
-              }
-            }
-          },
-          {
-            name: "Create Differentiator",
-            collection: "differentiators",
-            schema: differentiatorSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasPositioningArtifacts", target: "messaging" },
-        SKIP: { target: "messaging", actions: "recordSkip" }
-      }
-    },
-    messaging: {
-      description: "Craft your story using the StoryBrand framework",
-      meta: {
-        requiredArtifacts: {
-          "story-brands": { min: 1, description: "StoryBrand messaging" }
-        },
-        commands: [
-          {
-            name: "Create StoryBrand",
-            collection: "story-brands",
-            schema: storyBrandSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasMessagingArtifacts", target: "services" },
-        SKIP: { target: "services", actions: "recordSkip" }
-      }
-    },
-    services: {
-      description: "Define your delivery model and monetization \u2014 invokes ServicesBuilder",
-      meta: {
-        invokedBuilder: "services-builder"
-      },
-      on: {
-        SERVICES_COMPLETE: { target: "team" },
-        SKIP: { target: "team", actions: "recordSkip" }
-      }
-    },
-    team: {
-      description: "Define your org structure, agent roster, and OKRs",
-      meta: {
-        requiredArtifacts: {
-          agents: { min: 1, description: "Agent team members with objectives" }
-        },
-        commands: [
-          {
-            name: "Create Agent",
-            collection: "agents",
-            schema: agentSchema
-          },
-          {
-            name: "Create Roster from Template",
-            command: "agents create-roster",
-            schema: {
-              template: "solo | lean | full"
-            }
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasTeamArtifacts", target: "site" },
-        SKIP: { target: "site", actions: "recordSkip" }
-      }
-    },
-    site: {
-      description: "Build your web presence \u2014 invokes SiteBuilder",
-      meta: {
-        invokedBuilder: "site-builder"
-      },
-      on: {
-        SITE_COMPLETE: { target: "sales" },
-        SKIP: { target: "sales", actions: "recordSkip" }
-      }
-    },
-    sales: {
-      description: "Drive demand and measure results \u2014 invokes SalesBuilder",
-      meta: {
-        invokedBuilder: "sales-builder"
-      },
-      on: {
-        SALES_COMPLETE: { target: "complete", actions: "setResult" },
-        SKIP: { target: "complete", actions: "recordSkip" }
-      }
-    },
-    complete: {
-      type: "final",
-      description: "Builder complete \u2014 startup is now operating"
-    }
-  }
-});
-
-// src/machines/services-builder.ts
-import { setup as setup2, assign as assign2 } from "xstate";
-import { storyBrandSchema as storyBrandSchema2, serviceSchema, productSchema } from "startups.studio/schemas";
-var servicesBuilderMachine = setup2({
-  types: {
-    context: {},
-    events: {},
-    input: {}
-  },
-  guards: {
-    needsMessaging: ({ context }) => !context.hasStoryBrand,
-    hasMessaging: ({ context }) => context.hasStoryBrand,
-    hasModel: ({ context }) => context.deliveryModel !== void 0,
-    hasServices: ({ context }) => context.serviceCount >= 1,
-    hasPricing: ({ context }) => context.pricingSet,
-    hasProducts: ({ context }) => context.productCount >= 1
-  },
-  actions: {
-    setModel: assign2(({ event }) => ({
-      deliveryModel: event.type === "MODEL_SELECTED" ? event.model : void 0
-    })),
-    setPricing: assign2({ pricingSet: true }),
-    updateArtifactCount: assign2(({ context, event }) => {
-      if (event.type !== "ARTIFACT_CREATED") return context;
-      if (event.collection === "services") return { ...context, serviceCount: event.count };
-      if (event.collection === "products") return { ...context, productCount: event.count };
-      return context;
-    })
-  }
-}).createMachine({
-  id: "services-builder",
-  initial: "checkPrerequisites",
-  context: ({ input }) => ({
-    startupId: input.startupId,
-    hasStoryBrand: input.hasStoryBrand,
-    serviceCount: 0,
-    pricingSet: false,
-    productCount: 0,
-    activationComplete: false
-  }),
-  on: {
-    ARTIFACT_CREATED: { actions: "updateArtifactCount" }
-  },
-  states: {
-    checkPrerequisites: {
-      always: [
-        { guard: "needsMessaging", target: "messaging" },
-        { guard: "hasMessaging", target: "model" }
-      ]
-    },
-    messaging: {
-      description: "Prerequisite: Create StoryBrand messaging before defining services",
-      meta: {
-        prerequisite: true,
-        commands: [
-          {
-            name: "Create StoryBrand",
-            collection: "story-brands",
-            schema: storyBrandSchema2
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { target: "model" }
-      }
-    },
-    model: {
-      description: "Choose your delivery model",
-      meta: {
-        commands: [
-          {
-            name: "Select delivery model",
-            schema: {
-              model: "saas | iaas | paas | services-as-software"
-            }
-          }
-        ],
-        options: {
-          saas: "Software-as-a-Service \u2014 hosted application, user accounts, subscription billing",
-          iaas: "Infrastructure-as-a-Service \u2014 cloud resources, APIs, usage-based billing",
-          paas: "Platform-as-a-Service \u2014 developer tools, SDKs, build on top of your platform",
-          "services-as-software": "Services-as-Software \u2014 AI agents do the work, delivered as a service"
-        }
-      },
-      on: {
-        MODEL_SELECTED: { target: "definition", actions: "setModel" },
-        SKIP: { target: "definition" }
-      }
-    },
-    definition: {
-      description: "Define what your service does",
-      meta: {
-        requiredArtifacts: {
-          services: { min: 1, description: "Service definitions" }
-        },
-        commands: [
-          {
-            name: "Create Service",
-            collection: "services",
-            schema: serviceSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasServices", target: "pricing" },
-        SKIP: { target: "pricing" }
-      }
-    },
-    pricing: {
-      description: "Define pricing for your services",
-      meta: {
-        commands: [
-          {
-            name: "Set pricing on service",
-            collection: "services",
-            operation: "update",
-            schema: {
-              pricingModel: "subscription | usage | per-seat | per-agent | one-time",
-              price: "number: price in cents",
-              interval: "month | year (for subscription)",
-              tiers: [
-                {
-                  name: "Tier name",
-                  price: "number: price in cents",
-                  features: ["What is included in this tier"]
-                }
-              ]
-            }
-          }
-        ]
-      },
-      on: {
-        PRICING_SET: { target: "packaging", actions: "setPricing" },
-        ADVANCE: { guard: "hasPricing", target: "packaging" },
-        SKIP: { target: "packaging" }
-      }
-    },
-    packaging: {
-      description: "Bundle services into products and configure Stripe",
-      meta: {
-        requiredArtifacts: {
-          products: { min: 1, description: "Products with Stripe Price" }
-        },
-        commands: [
-          {
-            name: "Create Product",
-            collection: "products",
-            schema: productSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasProducts", target: "activation" },
-        SKIP: { target: "activation" }
-      }
-    },
-    activation: {
-      description: "Connect delivery infrastructure",
-      meta: {
-        commands: [
-          {
-            name: "Activate service delivery",
-            description: "Connect agents, workflows, or infrastructure to deliver the service",
-            schema: {
-              type: "agent | workflow | api | manual",
-              agent: "ID of agent that delivers this service (for services-as-software)",
-              workflow: "ID of workflow that executes delivery"
-            }
-          }
-        ]
-      },
-      on: {
-        ACTIVATION_COMPLETE: { target: "complete" },
-        ADVANCE: { target: "complete" },
-        SKIP: { target: "complete" }
-      }
-    },
-    complete: {
-      type: "final",
-      description: "Services defined and activated"
-    }
-  }
-});
-
-// src/machines/site-builder.ts
-import { setup as setup3, assign as assign3 } from "xstate";
-import { pageSchema, domainSchema } from "startups.studio/schemas";
-var siteBuilderMachine = setup3({
-  types: {
-    context: {},
-    events: {},
-    input: {}
-  },
-  guards: {
-    needsMessaging: ({ context }) => !context.hasStoryBrand,
-    needsServices: ({ context }) => context.hasStoryBrand && !context.hasServices,
-    hasPrerequisites: ({ context }) => context.hasStoryBrand && context.hasServices,
-    hasPages: ({ context }) => context.pageCount >= 1,
-    hasContent: ({ context }) => context.pagesWithContent >= context.pageCount && context.pageCount > 0,
-    hasDesign: ({ context }) => context.designApproved,
-    hasDomain: ({ context }) => context.domainCount >= 1
-  },
-  actions: {
-    updateArtifactCount: assign3(({ context, event }) => {
-      if (event.type !== "ARTIFACT_CREATED") return context;
-      if (event.collection === "pages") return { ...context, pageCount: event.count };
-      if (event.collection === "domains") return { ...context, domainCount: event.count };
-      return context;
-    }),
-    setContentComplete: assign3(({ event }) => ({
-      pagesWithContent: event.type === "CONTENT_COMPLETE" ? event.pagesWithContent : 0
-    })),
-    setDesignApproved: assign3({ designApproved: true }),
-    setPublished: assign3({ published: true })
-  }
-}).createMachine({
-  id: "site-builder",
-  initial: "checkPrerequisites",
-  context: ({ input }) => ({
-    startupId: input.startupId,
-    hasStoryBrand: input.hasStoryBrand,
-    hasServices: input.hasServices,
-    pageCount: 0,
-    pagesWithContent: 0,
-    domainCount: 0,
-    designApproved: false,
-    published: false
-  }),
-  on: {
-    ARTIFACT_CREATED: { actions: "updateArtifactCount" }
-  },
-  states: {
-    checkPrerequisites: {
-      always: [
-        { guard: "needsMessaging", target: "messaging" },
-        { guard: "needsServices", target: "servicesPrereq" },
-        { guard: "hasPrerequisites", target: "structure" }
-      ]
-    },
-    messaging: {
-      description: "Prerequisite: Create StoryBrand messaging first",
-      meta: { prerequisite: true },
-      on: {
-        ADVANCE: { target: "servicesPrereq" }
-      }
-    },
-    servicesPrereq: {
-      description: "Prerequisite: Define services and pricing first",
-      meta: { prerequisite: true, invokedBuilder: "services-builder" },
-      on: {
-        ADVANCE: { target: "structure" }
-      }
-    },
-    structure: {
-      description: "Define your site pages and navigation",
-      meta: {
-        requiredArtifacts: {
-          pages: { min: 1, description: "Site pages" }
-        },
-        commands: [
-          {
-            name: "Create Page",
-            collection: "pages",
-            schema: pageSchema
-          },
-          {
-            name: "Assign Domain",
-            collection: "domains",
-            schema: domainSchema
-          }
-        ]
-      },
-      on: {
-        ADVANCE: { guard: "hasPages", target: "content" },
-        SKIP: { target: "content" }
-      }
-    },
-    content: {
-      description: "Write content for each page using your StoryBrand and service definitions",
-      meta: {
-        commands: [
-          {
-            name: "Update Page Content",
-            collection: "pages",
-            operation: "update",
-            schema: {
-              content: "Page content \u2014 use StoryBrand for landing page, service details for pricing",
-              sections: [
-                {
-                  type: "hero | features | pricing | testimonials | cta | faq",
-                  content: "Section content in markdown"
-                }
-              ]
-            }
-          }
-        ]
-      },
-      on: {
-        CONTENT_COMPLETE: { actions: "setContentComplete" },
-        ADVANCE: { guard: "hasContent", target: "design" },
-        SKIP: { target: "design" }
-      }
-    },
-    design: {
-      description: "Style your site using mdxui components",
-      meta: {
-        commands: [
-          {
-            name: "Update Site Design",
-            collection: "sites",
-            operation: "update",
-            schema: {
-              theme: "Theme name or configuration",
-              layout: "default | minimal | bold | corporate",
-              colors: {
-                primary: "Hex color code",
-                secondary: "Hex color code",
-                accent: "Hex color code"
-              }
-            }
-          }
-        ]
-      },
-      on: {
-        DESIGN_APPROVED: { actions: "setDesignApproved" },
-        ADVANCE: { target: "publish" },
-        SKIP: { target: "publish" }
-      }
-    },
-    publish: {
-      description: "Deploy your site to your domain",
-      meta: {
-        requiredArtifacts: {
-          domains: { min: 1, description: "Domain assigned" }
-        },
-        commands: [
-          {
-            name: "Publish Site",
-            command: "sites publish",
-            schema: {
-              startup: "Startup ID"
-            }
-          }
-        ]
-      },
-      on: {
-        PUBLISHED: { target: "complete", actions: "setPublished" },
-        ADVANCE: { guard: "hasDomain", target: "complete" },
-        SKIP: { target: "complete" }
-      }
-    },
-    complete: {
-      type: "final",
-      description: "Site published and live"
-    }
-  }
-});
-
-// src/machines/sales-builder.ts
-import { setup as setup4, assign as assign4 } from "xstate";
-import {
-  campaignSchema,
-  sequenceSchema,
-  postSchema,
-  experimentSchema,
-  budgetSchema,
-  accountSchema
-} from "startups.studio/schemas";
-var salesBuilderMachine = setup4({
-  types: {
-    context: {},
-    events: {},
-    input: {}
-  },
-  guards: {
-    needsSite: ({ context }) => !context.hasSite || !context.hasDomain,
-    hasSite: ({ context }) => context.hasSite && context.hasDomain,
-    hasActiveChannel: ({ context }) => context.campaignCount >= 1 || context.sequenceCount >= 1 || context.postCount >= 1,
-    hasMetrics: ({ context }) => context.hasMetrics
-  },
-  actions: {
-    updateArtifactCount: assign4(({ context, event }) => {
-      if (event.type !== "ARTIFACT_CREATED") return context;
-      if (event.collection === "campaigns") return { ...context, campaignCount: event.count };
-      if (event.collection === "sequences") return { ...context, sequenceCount: event.count };
-      if (event.collection === "posts") return { ...context, postCount: event.count };
-      return context;
-    }),
-    setExperiment: assign4(({ event }) => ({
-      hasExperiment: true,
-      experimentId: event.type === "EXPERIMENT_CREATED" ? event.experimentId : void 0
-    })),
-    setMetrics: assign4({ hasMetrics: true })
-  }
-}).createMachine({
-  id: "sales-builder",
-  initial: "checkPrerequisites",
-  context: ({ input }) => ({
-    startupId: input.startupId,
-    hasSite: input.hasSite,
-    hasDomain: input.hasDomain,
-    channels: {
-      paidAds: { ready: false, reason: "Requires payment method and approved budget" },
-      coldOutbound: { ready: false, reason: "Requires email-configured domain and contacts" },
-      contentSocial: { ready: false, reason: "Requires connected account for platform" },
-      blog: { ready: true }
-    },
-    campaignCount: 0,
-    sequenceCount: 0,
-    postCount: 0,
-    hasExperiment: false,
-    hasMetrics: false
-  }),
-  on: {
-    ARTIFACT_CREATED: { actions: "updateArtifactCount" }
-  },
-  states: {
-    checkPrerequisites: {
-      always: [
-        { guard: "needsSite", target: "sitePrereq" },
-        { guard: "hasSite", target: "launch" }
-      ]
-    },
-    sitePrereq: {
-      description: "Prerequisite: Build and publish your site first",
-      meta: { prerequisite: true, invokedBuilder: "site-builder" },
-      on: {
-        ADVANCE: { target: "launch" }
-      }
-    },
-    launch: {
-      description: "Drive traffic to test your hypothesis",
-      meta: {
-        requiredArtifacts: {
-          _any: {
-            min: 1,
-            description: "At least one active campaign, sequence, or post",
-            collections: ["campaigns", "sequences", "posts"]
-          }
-        },
-        channelCommands: {
-          paidAds: {
-            prerequisiteLabel: "Requires: payment method, approved budget",
-            prerequisiteCommands: [
-              {
-                name: "Create Budget",
-                collection: "budgets",
-                schema: budgetSchema
-              }
-            ],
-            command: {
-              name: "Create Campaign",
-              collection: "campaigns",
-              schema: campaignSchema
-            }
-          },
-          coldOutbound: {
-            prerequisiteLabel: "Requires: email-configured domain, contacts",
-            prerequisiteCommands: [
-              {
-                name: "Configure email on domain",
-                collection: "domains",
-                operation: "update",
-                schema: { email: "boolean: true" }
-              },
-              {
-                name: "Search contacts",
-                command: "contacts search",
-                api: "api.sb",
-                schema: {
-                  industry: "NAICS code",
-                  role: "Job title to target",
-                  companySize: "number: employee count range",
-                  limit: "number: max results"
-                }
-              }
-            ],
-            command: {
-              name: "Create Sequence",
-              collection: "sequences",
-              schema: sequenceSchema
-            }
-          },
-          contentSocial: {
-            prerequisiteLabel: "Requires: connected account for platform",
-            prerequisiteCommands: [
-              {
-                name: "Connect account",
-                collection: "accounts",
-                schema: accountSchema
-              }
-            ],
-            command: {
-              name: "Create Post",
-              collection: "posts",
-              schema: postSchema
-            }
-          },
-          blog: {
-            prerequisiteLabel: "Ready (published on your domain)",
-            command: {
-              name: "Create Blog Post",
-              collection: "posts",
-              schema: postSchema
-            }
-          }
-        }
-      },
-      on: {
-        ADVANCE: { guard: "hasActiveChannel", target: "measure" },
-        SKIP: { target: "measure" }
-      }
-    },
-    measure: {
-      description: "Collect data and track results against your OKRs",
-      meta: {
-        commands: [
-          {
-            name: "Create Experiment",
-            collection: "experiments",
-            schema: experimentSchema
-          },
-          {
-            name: "Record Metrics",
-            collection: "experiments",
-            operation: "update",
-            schema: {
-              metrics: {
-                visitors: "number: unique visitors",
-                signups: "number: signups or leads captured",
-                conversionRate: "number: percentage",
-                revenue: "number: dollars"
-              },
-              evidence: "What you observed"
-            }
-          },
-          {
-            name: "View current metrics",
-            command: "status",
-            description: "See current OKR progress and health scores"
-          }
-        ]
-      },
-      on: {
-        METRICS_COLLECTED: { target: "complete", actions: "setMetrics" },
-        ADVANCE: { guard: "hasMetrics", target: "complete" },
-        SKIP: { target: "complete" }
-      }
-    },
-    complete: {
-      type: "final",
-      description: "Sales cycle complete \u2014 review results against OKRs to determine next steps"
-    }
-  }
-});
-
-// src/reconcile.ts
-import { apiRequest } from "startups.studio";
-var COLLECTION_MAP = [
-  { collection: "icps", key: "icpCount" },
-  { collection: "competitors", key: "competitorCount" },
-  { collection: "lean-canvases", key: "leanCanvasCount" },
-  { collection: "hypotheses", key: "hypothesisCount" },
-  { collection: "differentiators", key: "differentiatorCount" },
-  { collection: "story-brands", key: "storyBrandCount" },
-  { collection: "services", key: "serviceCount" },
-  { collection: "agents", key: "agentCount" },
-  { collection: "domains", key: "domainCount" },
-  { collection: "pages", key: "pageCount" }
-];
-async function fetchArtifactCounts(startupId, apiBaseUrl, apiKey) {
-  const counts = {
-    icpCount: 0,
-    competitorCount: 0,
-    leanCanvasCount: 0,
-    hypothesisCount: 0,
-    positioningSet: false,
-    differentiatorCount: 0,
-    storyBrandCount: 0,
-    serviceCount: 0,
-    agentCount: 0,
-    domainCount: 0,
-    pageCount: 0
-  };
-  const results = await Promise.allSettled(
-    COLLECTION_MAP.map(async ({ collection, key }) => {
-      const path = `/api/${collection}?where[startup][equals]=${encodeURIComponent(startupId)}&limit=0`;
-      const result = await apiRequest(apiBaseUrl, path, { apiKey });
-      if (result.ok) {
-        return { key, count: result.data.totalDocs };
-      }
-      return { key, count: 0 };
-    })
-  );
-  for (const result of results) {
-    if (result.status === "fulfilled") {
-      const { key, count } = result.value;
-      counts[key] = count;
-    }
-  }
-  const startupResult = await apiRequest(
-    apiBaseUrl,
-    `/api/startups/${encodeURIComponent(startupId)}?depth=0`,
-    { apiKey }
-  );
-  if (startupResult.ok && startupResult.data.positioning) {
-    counts.positioningSet = true;
-  }
-  return counts;
-}
-function determineCurrentState(counts) {
-  const transitions = [
-    {
-      from: "research",
-      to: "canvas",
-      guard: (c) => c.icpCount >= 1 && c.competitorCount >= 1
-    },
-    {
-      from: "canvas",
-      to: "positioning",
-      guard: (c) => c.leanCanvasCount >= 1 && c.hypothesisCount >= 1
-    },
-    {
-      from: "positioning",
-      to: "messaging",
-      guard: (c) => c.positioningSet && c.differentiatorCount >= 1
-    },
-    {
-      from: "messaging",
-      to: "services",
-      guard: (c) => c.storyBrandCount >= 1
-    },
-    {
-      from: "services",
-      to: "team",
-      guard: (c) => c.serviceCount >= 1
-    },
-    {
-      from: "team",
-      to: "site",
-      guard: (c) => c.agentCount >= 1
-    },
-    {
-      from: "site",
-      to: "sales",
-      guard: (c) => c.domainCount >= 1 && c.pageCount >= 1
-    }
-  ];
-  let current = "research";
-  for (const t of transitions) {
-    if (t.from !== current) continue;
-    if (t.guard(counts)) {
-      current = t.to;
-    } else {
-      break;
-    }
-  }
-  return current;
-}
-
-// src/runner.ts
-var STATE_ORDER = [
-  { key: "research", label: "Research" },
-  { key: "canvas", label: "Canvas" },
-  { key: "positioning", label: "Positioning" },
-  { key: "messaging", label: "Messaging" },
-  { key: "services", label: "Services" },
-  { key: "team", label: "Team" },
-  { key: "site", label: "Site" },
-  { key: "sales", label: "Sales" },
-  { key: "complete", label: "Complete" }
-];
-async function reconcileState(startupId, apiBaseUrl, apiKey) {
-  const counts = await fetchArtifactCounts(startupId, apiBaseUrl, apiKey);
-  const currentState = determineCurrentState(counts);
-  return { currentState, counts };
-}
-function getProgress(currentState) {
-  let found = false;
-  return STATE_ORDER.map(({ key, label }) => {
-    if (key === currentState) {
-      found = true;
-      return { state: key, label, status: "current" };
-    }
-    if (!found) {
-      return { state: key, label, status: "complete" };
-    }
-    return { state: key, label, status: "pending" };
-  });
-}
-function getNextCommands(currentState, startupId) {
-  const stateNode = startupBuilderMachine.config.states?.[currentState];
-  if (!stateNode) return [];
-  const meta = stateNode.meta;
-  if (!meta) return [];
-  const commands = meta.commands;
-  if (!commands || !Array.isArray(commands)) return [];
-  return commands.map((cmd) => {
-    const operation = cmd.operation || "create";
-    const collection = cmd.collection;
-    let cliCommand;
-    if (cmd.command) {
-      cliCommand = `startups.studio ${cmd.command} --startup ${startupId}`;
-    } else if (operation === "update") {
-      cliCommand = `startups.studio ${collection} update ${startupId}`;
-    } else {
-      cliCommand = `startups.studio ${collection} create --startup ${startupId}`;
-    }
-    const description = stateNode.description || "";
-    return {
-      name: cmd.name,
-      collection,
-      operation,
-      command: cliCommand,
-      schema: cmd.schema,
-      description
-    };
-  });
-}
-function getRequiredArtifacts(currentState, counts) {
-  const stateNode = startupBuilderMachine.config.states?.[currentState];
-  if (!stateNode) return [];
-  const meta = stateNode.meta;
-  if (!meta?.requiredArtifacts) return [];
-  const required = meta.requiredArtifacts;
-  const countMap = {
-    icps: counts.icpCount,
-    competitors: counts.competitorCount,
-    "lean-canvases": counts.leanCanvasCount,
-    hypotheses: counts.hypothesisCount,
-    differentiators: counts.differentiatorCount,
-    "story-brands": counts.storyBrandCount,
-    services: counts.serviceCount,
-    agents: counts.agentCount,
-    domains: counts.domainCount,
-    pages: counts.pageCount,
-    positioning: counts.positioningSet ? 1 : 0
-  };
-  return Object.entries(required).map(([collection, spec]) => ({
-    collection,
-    description: spec.description,
-    required: spec.min,
-    current: countMap[collection] ?? 0
-  }));
-}
-
-export {
-  startupBuilderMachine,
-  servicesBuilderMachine,
-  siteBuilderMachine,
-  salesBuilderMachine,
-  fetchArtifactCounts,
-  reconcileState,
-  getProgress,
-  getNextCommands,
-  getRequiredArtifacts
-};