feat: af paperclip init — one-command company bootstrap from blueprints

New commands:
- `af paperclip init --blueprint dev-shop` — creates a complete Paperclip
  company with agents, goals, and starter tasks in one command
- `af paperclip blueprints` — list available company templates

5 blueprints: dev-shop, marketing-agency, sales-team, content-studio,
support-center. Each defines agent roles, starter tasks, and company goals.

Init flow:
1. Matches AF marketplace agents to blueprint slots
2. Creates Paperclip company + goal
3. Deploys agents with correct roles and heartbeat config
4. Creates starter tasks assigned to agents

New playbook: `af playbook company-from-scratch` — step-by-step guide
for creating an AI company from zero using AgenticFlow + Paperclip.

Verified by sub-agent: marketing-agency blueprint → 4 agents deployed,
3 tasks created, gateway connected, CMO agent executed task successfully.

Author: seanphan

packages/cli/src/cli/company-blueprints.ts

@@ -0,0 +1,126 @@
+/**
+ * Pre-built company blueprints for Paperclip deployment.
+ *
+ * Each blueprint defines a team of AgenticFlow agents that can be
+ * deployed to Paperclip as a ready-made company. Agents are sourced
+ * from the AF marketplace templates or the user's existing agents.
+ */
+
+export interface AgentSlot {
+  /** Paperclip role */
+  role: string;
+  /** What this slot does */
+  title: string;
+  /** Human description */
+  description: string;
+  /** Suggested AF agent name to search for (from marketplace) */
+  suggestedTemplate?: string;
+  /** Allow user to skip this slot */
+  optional?: boolean;
+}
+
+export interface CompanyBlueprint {
+  /** Short slug */
+  id: string;
+  /** Display name */
+  name: string;
+  /** What this company does */
+  description: string;
+  /** Company goal */
+  goal: string;
+  /** Starter tasks */
+  starterTasks: Array<{ title: string; description: string; assigneeRole: string; priority: string }>;
+  /** Agent slots to fill */
+  agents: AgentSlot[];
+}
+
+export const BLUEPRINTS: Record<string, CompanyBlueprint> = {
+  "dev-shop": {
+    id: "dev-shop",
+    name: "Software Dev Shop",
+    description: "A lean engineering team that builds and ships software products.",
+    goal: "Build and ship high-quality software products",
+    agents: [
+      { role: "ceo", title: "CEO / Tech Lead", description: "Strategic direction, delegation, project oversight" },
+      { role: "engineer", title: "Senior Engineer", description: "Core development, architecture, code implementation" },
+      { role: "designer", title: "UX Designer", description: "UI/UX design, user research, visual design", optional: true },
+      { role: "qa", title: "QA Engineer", description: "Testing, bug finding, quality assurance", optional: true },
+    ],
+    starterTasks: [
+      { title: "Define product roadmap", description: "Create a 3-month product roadmap with milestones and deliverables.", assigneeRole: "ceo", priority: "high" },
+      { title: "Set up project architecture", description: "Design the technical architecture and set up the development environment.", assigneeRole: "engineer", priority: "high" },
+    ],
+  },
+  "marketing-agency": {
+    id: "marketing-agency",
+    name: "Marketing Agency",
+    description: "A full-service marketing team for content, social media, SEO, and campaigns.",
+    goal: "Drive brand awareness and customer acquisition through multi-channel marketing",
+    agents: [
+      { role: "ceo", title: "Agency Director", description: "Strategy, client relations, campaign oversight" },
+      { role: "cmo", title: "Content Strategist", description: "Content planning, blog posts, newsletters", suggestedTemplate: "Content Writer" },
+      { role: "designer", title: "Visual Designer", description: "Graphics, social media visuals, brand assets", suggestedTemplate: "Visual designer" },
+      { role: "researcher", title: "Market Researcher", description: "Competitive analysis, trend research", suggestedTemplate: "Ari, the Market Researcher", optional: true },
+    ],
+    starterTasks: [
+      { title: "Develop content calendar", description: "Create a 4-week content calendar covering blog posts, social media, and email newsletters.", assigneeRole: "cmo", priority: "high" },
+      { title: "Create brand guidelines", description: "Define color palette, typography, logo usage, and visual style for all marketing materials.", assigneeRole: "designer", priority: "high" },
+      { title: "Competitive landscape report", description: "Research top 5 competitors and summarize their positioning, pricing, and marketing strategies.", assigneeRole: "researcher", priority: "medium" },
+    ],
+  },
+  "sales-team": {
+    id: "sales-team",
+    name: "Sales Team",
+    description: "A sales operation with outreach, research, and customer management.",
+    goal: "Generate qualified leads and close deals",
+    agents: [
+      { role: "ceo", title: "Sales Director", description: "Pipeline management, strategy, team coordination" },
+      { role: "researcher", title: "Sales Researcher", description: "Lead research, company profiling, ICP matching", suggestedTemplate: "Olivia, the Sales Strategist" },
+      { role: "general", title: "SDR / Outreach", description: "Email outreach, follow-ups, scheduling", suggestedTemplate: "Rachel, the Support Agent" },
+    ],
+    starterTasks: [
+      { title: "Define ICP and target list", description: "Create ideal customer profile and build a list of 50 target companies.", assigneeRole: "researcher", priority: "high" },
+      { title: "Write outreach sequences", description: "Draft 3-step email sequences for cold outreach, follow-up, and re-engagement.", assigneeRole: "general", priority: "high" },
+    ],
+  },
+  "content-studio": {
+    id: "content-studio",
+    name: "Content Studio",
+    description: "A creative content production team for video, social, and written content.",
+    goal: "Produce high-quality content across video, social media, and written formats",
+    agents: [
+      { role: "ceo", title: "Creative Director", description: "Content strategy, quality control, brand voice" },
+      { role: "cmo", title: "Social Media Manager", description: "Social media scheduling, engagement, analytics", suggestedTemplate: "Mason, the Social Media Manager" },
+      { role: "engineer", title: "Content Writer", description: "Blog posts, articles, scripts, copy", suggestedTemplate: "Content Writer" },
+      { role: "designer", title: "Visual Creator", description: "Graphics, thumbnails, social visuals", suggestedTemplate: "Visual designer", optional: true },
+    ],
+    starterTasks: [
+      { title: "Create content pillars", description: "Define 3-5 content themes/pillars that align with the brand and audience.", assigneeRole: "ceo", priority: "high" },
+      { title: "Write 5 blog posts", description: "Draft 5 blog posts of 800-1200 words each on the defined content pillars.", assigneeRole: "engineer", priority: "high" },
+      { title: "Design social media templates", description: "Create reusable templates for Instagram, Twitter, and LinkedIn posts.", assigneeRole: "designer", priority: "medium" },
+    ],
+  },
+  "support-center": {
+    id: "support-center",
+    name: "Customer Support Center",
+    description: "A customer support team with triage, resolution, and escalation.",
+    goal: "Provide fast, helpful customer support and maintain high satisfaction",
+    agents: [
+      { role: "ceo", title: "Support Manager", description: "Escalation handling, SLA monitoring, team coordination" },
+      { role: "general", title: "Support Agent", description: "Ticket triage, first response, common issue resolution", suggestedTemplate: "Rachel, the Support Agent" },
+      { role: "researcher", title: "Knowledge Base Manager", description: "FAQ maintenance, documentation, self-service content", optional: true },
+    ],
+    starterTasks: [
+      { title: "Set up support playbook", description: "Create a support playbook with common issues, resolution steps, and escalation criteria.", assigneeRole: "ceo", priority: "high" },
+      { title: "Draft FAQ document", description: "Write an FAQ with the top 20 most common customer questions and answers.", assigneeRole: "researcher", priority: "medium" },
+    ],
+  },
+};
+
+export function listBlueprints(): CompanyBlueprint[] {
+  return Object.values(BLUEPRINTS);
+}
+
+export function getBlueprint(id: string): CompanyBlueprint | null {
+  return BLUEPRINTS[id] ?? null;
+}

packages/cli/src/cli/main.ts

@@ -24,6 +24,7 @@ import { PaperclipConnector } from "./gateway/connectors/paperclip.js";
 import { LinearConnector } from "./gateway/connectors/linear.js";
 import { WebhookConnector } from "./gateway/connectors/webhook.js";
 import type { ChannelConnector } from "./gateway/connector.js";
+import { listBlueprints, getBlueprint } from "./company-blueprints.js";
 import {
   OperationRegistry,
   defaultSpecPath,
@@ -4326,6 +4327,171 @@ export function createProgram(): Command {
     .command("paperclip")
     .description("Publish and control AgenticFlow agents on a Paperclip instance.");
 
+  // ─── init (bootstrap a company from blueprint) ──────────────────
+  pcOpts.both(paperclipCmd
+    .command("init")
+    .description("Bootstrap a Paperclip company from a pre-built blueprint with AgenticFlow agents."))
+    .requiredOption("--blueprint <id>", "Blueprint ID (use --list to see available)")
+    .option("--list", "List available blueprints")
+    .option("--budget <cents>", "Monthly budget in cents", "50000")
+    .action(async (opts: Record<string, unknown>) => {
+      // List mode
+      if (opts.list) {
+        printResult(listBlueprints().map((b) => ({
+          id: b.id,
+          name: b.name,
+          description: b.description,
+          agents: b.agents.length,
+          tasks: b.starterTasks.length,
+        })));
+        return;
+      }
+
+      const bp = getBlueprint(opts.blueprint as string);
+      if (!bp) {
+        fail("blueprint_not_found", `Unknown blueprint: ${opts.blueprint}`,
+          `Available: ${listBlueprints().map((b) => b.id).join(", ")}`);
+      }
+
+      const client = buildClient(program.opts());
+      const paperclipUrl = resolvePaperclipUrl(opts.paperclipUrl as string | undefined);
+      const pc = new PaperclipResource({ baseUrl: paperclipUrl });
+
+      const healthy = await pc.healthCheck();
+      if (!healthy) fail("paperclip_unreachable", `Cannot reach Paperclip at ${paperclipUrl}`);
+
+      if (!isJsonFlagEnabled()) console.error(`\nBootstrapping "${bp.name}" company...\n`);
+
+      // 1. List AF agents to match against blueprint slots
+      const afAgents = (await client.agents.list({ limit: 100 })) as Array<Record<string, unknown>>;
+
+      // 2. Create company
+      const company = await pc.createCompany({
+        name: bp.name,
+        description: bp.description,
+        budgetMonthlyCents: Number.parseInt(opts.budget as string, 10) || 50000,
+      });
+      savePaperclipCompanyId(company.id);
+      if (!isJsonFlagEnabled()) console.error(`  Company: ${company.name} (${company.id})`);
+
+      // 3. Create goal
+      const goal = await pc.createGoal(company.id, {
+        title: bp.goal,
+        level: "company",
+        status: "active",
+      });
+      if (!isJsonFlagEnabled()) console.error(`  Goal: ${bp.goal}`);
+
+      // 4. Deploy agents — match AF agents to blueprint slots
+      const deployed: Array<{ slot: string; afAgent: string; pcAgent: string; role: string }> = [];
+      const afBaseUrl = DEFAULT_BASE_URL;
+      const afApiKey = resolveToken(program.opts());
+
+      for (const slot of bp.agents) {
+        // Find best matching AF agent
+        let match = afAgents.find((a) =>
+          slot.suggestedTemplate && (a.name as string)?.toLowerCase().includes(slot.suggestedTemplate!.toLowerCase()),
+        );
+        if (!match) match = afAgents[0]; // Fallback to first available
+        if (!match) {
+          if (!isJsonFlagEnabled()) console.error(`  Skipped: ${slot.title} (no AF agent available)`);
+          continue;
+        }
+
+        const afId = match.id as string;
+        const afName = match.name as string;
+        const afModel = (match.model as string) ?? "";
+        const afDesc = (match.description as string) ?? "";
+        const streamUrl = `${afBaseUrl.replace(/\/+$/, "")}/v1/agents/${afId}/stream`;
+
+        const pcAgent = await pc.createAgent(company.id, {
+          name: afName,
+          role: slot.role,
+          title: slot.title,
+          capabilities: slot.description + (afDesc ? ` | AF: ${afDesc}` : ""),
+          adapterType: "http",
+          adapterConfig: {
+            url: streamUrl,
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...(afApiKey ? { Authorization: `Bearer ${afApiKey}` } : {}),
+            },
+            payloadTemplate: { messages: [{ content: "Execute your assigned task.", role: "user" }] },
+          },
+          runtimeConfig: {
+            heartbeat: { enabled: true, intervalSec: 0, wakeOnDemand: true },
+          },
+          metadata: {
+            af_agent_id: afId,
+            af_model: afModel,
+            af_stream_url: streamUrl,
+            blueprint: bp.id,
+            slot: slot.role,
+            deployed_at: new Date().toISOString(),
+          },
+        });
+
+        deployed.push({ slot: slot.title, afAgent: afName, pcAgent: pcAgent.id, role: slot.role });
+        if (!isJsonFlagEnabled()) console.error(`  Agent: ${afName} → ${slot.role} (${pcAgent.id})`);
+      }
+
+      // 5. Create starter tasks
+      const roleToAgent = new Map(deployed.map((d) => [d.role, d.pcAgent]));
+      const tasks: Array<{ identifier: string; title: string; assignee: string }> = [];
+
+      for (const task of bp.starterTasks) {
+        const assignee = roleToAgent.get(task.assigneeRole);
+        if (!assignee) continue;
+
+        const issue = await pc.createIssue(company.id, {
+          title: task.title,
+          description: task.description,
+          priority: task.priority,
+          assigneeAgentId: assignee,
+          goalId: goal.id,
+          status: "todo",
+        });
+        const iss = issue as unknown as Record<string, unknown>;
+        tasks.push({ identifier: (iss.identifier as string) ?? "", title: task.title, assignee });
+        if (!isJsonFlagEnabled()) console.error(`  Task: ${iss.identifier} → ${task.title}`);
+      }
+
+      if (!isJsonFlagEnabled()) {
+        console.error(`\n  Done! ${deployed.length} agents deployed, ${tasks.length} tasks created.`);
+        console.error(`  Next: af gateway serve --channels paperclip && af paperclip connect --company-id ${company.id}`);
+      }
+
+      printResult({
+        schema: "agenticflow.paperclip.init.v1",
+        blueprint: bp.id,
+        company: { id: company.id, name: company.name },
+        goal: { id: goal.id, title: bp.goal },
+        agents: deployed,
+        tasks,
+      });
+    });
+
+  // ─── blueprints ─────────────────────────────────────────────────
+  paperclipCmd
+    .command("blueprints")
+    .description("List available company blueprints for `af paperclip init`.")
+    .action(() => {
+      const bps = listBlueprints();
+      if (isJsonFlagEnabled()) {
+        printResult(bps.map((b) => ({ id: b.id, name: b.name, description: b.description, agents: b.agents.length })));
+      } else {
+        console.log("Available company blueprints:\n");
+        for (const b of bps) {
+          console.log(`  ${b.id}`);
+          console.log(`    ${b.name} — ${b.description}`);
+          console.log(`    Agents: ${b.agents.map((a) => a.role).join(", ")}`);
+          console.log("");
+        }
+        console.log("Use: af paperclip init --blueprint <id>");
+      }
+    });
+
   // ─── deploy ─────────────────────────────────────────────────────
   const pcDeploy = paperclipCmd
     .command("deploy")