create-yonderclaw 1.0.0

package/installer/scaffold-from-config.ts

@@ -0,0 +1,270 @@
+/**
+ * MetaClaw v3.3 — Module-Driven Scaffold
+ *
+ * Reads config JSON, discovers modules, resolves dependencies,
+ * copies templates with placeholders, assembles CLAUDE.md, generates dashboard.
+ *
+ * Usage: npx tsx installer/scaffold-from-config.ts <config.json> <output-dir> [modules-dir]
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { generateDashboard } from "./dashboard-generator.js";
+import { generateStarterTasks } from "./task-generator.js";
+import {
+  discoverModules, resolveModulesToInstall, buildPlaceholders,
+  processModuleContributes, mergeNpmScripts, mergeDependencies,
+  buildClaudeMd, writeModulesJson, copyTemplate,
+  type LoadedModule, type InstallConfig
+} from "./module-loader.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const configPath = process.argv[2];
+const outputDir = process.argv[3];
+const modulesArg = process.argv[4];
+
+if (!configPath || !outputDir) {
+  console.error("Usage: npx tsx installer/scaffold-from-config.ts <config.json> <output-dir> [modules-dir]");
+  process.exit(1);
+}
+
+// --- Find modules directory ---
+// Tauri flattens resources, so modules might be in several locations
+const candidates = [
+  modulesArg,
+  path.join(__dirname, "modules"),
+  path.join(outputDir, "installer", "modules"),
+  path.join(outputDir, "modules"),
+  path.join(process.cwd(), "installer", "modules"),
+  path.join(process.cwd(), "modules"),
+  // Tauri extracts resources — check multiple possible locations
+  ...(modulesArg ? [path.join(modulesArg, "modules"), path.join(modulesArg, "installer", "modules")] : []),
+].filter(Boolean) as string[];
+
+let MODULES_DIR = "";
+for (const c of candidates) {
+  const coreManifest = path.join(c, "core", "metaclaw-module.json");
+  if (fs.existsSync(coreManifest)) { MODULES_DIR = c; break; }
+}
+
+// Fallback: check if templates are in flat structure (old format / Tauri bundle)
+if (!MODULES_DIR) {
+  // Try old templates dir for backward compatibility
+  const oldCandidates = [
+    path.join(__dirname, "templates"),
+    path.join(outputDir, "installer", "templates"),
+    outputDir,
+  ];
+  for (const c of oldCandidates) {
+    if (fs.existsSync(path.join(c, "db.ts.txt"))) {
+      console.warn("WARNING: Using legacy flat templates. Module system not found.");
+      console.warn("Tried: " + candidates.join(", "));
+      // Fall through to legacy mode below
+      break;
+    }
+  }
+}
+
+if (!MODULES_DIR) {
+  // Debug: list what's actually in the output dir
+  console.error("Module system not found. Tried:");
+  for (const c of candidates) {
+    const exists = fs.existsSync(c);
+    const coreExists = fs.existsSync(path.join(c, "core", "metaclaw-module.json"));
+    console.error(`  ${c} (exists: ${exists}, core: ${coreExists})`);
+  }
+  console.error("Output dir contents:");
+  try {
+    const listDir = (p: string, indent: number) => {
+      for (const f of fs.readdirSync(p)) {
+        if (f === "node_modules") continue;
+        const fp = path.join(p, f);
+        console.error("  ".repeat(indent) + f);
+        if (fs.statSync(fp).isDirectory() && indent < 3) listDir(fp, indent + 1);
+      }
+    };
+    listDir(outputDir, 1);
+  } catch {}
+  process.exit(1);
+}
+
+console.log("Using modules: " + MODULES_DIR);
+
+// --- Load config ---
+const config: InstallConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+const agentName = config.agentName || "Atlas";
+const clawType = config.clawType || "custom";
+const sessionName = agentName.toLowerCase().replace(/[^a-z0-9]/g, "-");
+
+console.log(`Scaffolding ${agentName} (${clawType}) to ${outputDir}...`);
+
+// --- Discover and resolve modules ---
+const allModules = discoverModules(MODULES_DIR);
+console.log(`Discovered ${allModules.length} modules: ${allModules.map(m => m.manifest.name).join(", ")}`);
+
+const modulesToInstall = resolveModulesToInstall(allModules, config);
+console.log(`Installing ${modulesToInstall.length} modules: ${modulesToInstall.map(m => m.manifest.name).join(", ")}`);
+
+// --- Build placeholders ---
+const systemPrompt = buildSystemPrompt(config);
+const placeholders = buildPlaceholders(config, outputDir);
+// Add system prompt (needs special escaping for template embedding)
+placeholders["__SYSTEM_PROMPT__"] = systemPrompt.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+
+// --- Create base directories ---
+for (const d of ["src", "src/tools", "data", "data/logs", "scripts"]) {
+  fs.mkdirSync(path.join(outputDir, d), { recursive: true });
+}
+
+// --- Process each module ---
+const packageJson: any = {
+  name: config.projectName || sessionName,
+  version: "1.0.0",
+  type: "module",
+  description: `${clawType} agent — MetaClaw v3.3.0`,
+  scripts: {},
+  dependencies: {},
+};
+
+for (const mod of modulesToInstall) {
+  console.log(`  Installing module: ${mod.manifest.displayName}`);
+  processModuleContributes(mod, outputDir, placeholders);
+}
+
+// Merge npm scripts and dependencies from all modules
+mergeNpmScripts(packageJson, modulesToInstall);
+mergeDependencies(packageJson, modulesToInstall);
+
+// Add test script
+packageJson.scripts.test = "echo Tests not configured";
+
+// Write package.json
+fs.writeFileSync(path.join(outputDir, "package.json"), JSON.stringify(packageJson, null, 2));
+
+// --- Assemble CLAUDE.md ---
+const claudeMd = buildClaudeMd(modulesToInstall, config, systemPrompt);
+fs.writeFileSync(path.join(outputDir, "CLAUDE.md"), claudeMd);
+
+// --- SOUL.md ---
+fs.writeFileSync(path.join(outputDir, "SOUL.md"), [
+  `# ${agentName} — Principles`, "",
+  "1. Verify outputs before presenting",
+  "2. Acknowledge uncertainty",
+  "3. Prefer established approaches",
+  "4. Break into verifiable sub-tasks",
+  "5. Explain reasoning",
+  "6. Stop on failure loops",
+  "7. No irreversible actions without confirmation",
+  "8. Track cost and impact",
+  "9. ALWAYS deposit insights to QIS buckets after completing tasks",
+  "10. ALWAYS check relevant buckets before starting work",
+  "", "## System Prompt", systemPrompt
+].join("\n"));
+
+// --- HEARTBEAT.md ---
+fs.writeFileSync(path.join(outputDir, "HEARTBEAT.md"), "# Heartbeat\nLast run: never");
+
+// --- Dashboard ---
+fs.writeFileSync(path.join(outputDir, "dashboard.html"), generateDashboard(agentName, clawType, config));
+
+// Favicon
+const favCandidates = [
+  path.join(__dirname, "assets", "favicon.png"),
+  path.join(outputDir, "installer", "assets", "favicon.png"),
+  path.join(outputDir, "favicon.png"),
+  path.join(process.cwd(), "favicon.png"),
+];
+const fav = favCandidates.find(f => fs.existsSync(f)) || "";
+if (fs.existsSync(fav)) fs.copyFileSync(fav, path.join(outputDir, "favicon.png"));
+
+// --- Init scripts (these are config-specific, generated inline) ---
+const ms = (parseInt(config.updateInterval) || 6) * 60 * 60 * 1000;
+fs.writeFileSync(path.join(outputDir, "src", "init-config.ts"),
+  `import{getDb,setConfig}from"./db.js";getDb();setConfig("self_update_interval_ms","${ms}");setConfig("agent_name",${JSON.stringify(agentName)});setConfig("template",${JSON.stringify(clawType)});setConfig("created_at",new Date().toISOString());console.log("Config initialized.");`);
+fs.writeFileSync(path.join(outputDir, "src", "init-prompts.ts"),
+  `import{getDb}from"./db.js";const db=getDb();const t=${JSON.stringify(clawType)};const c=${JSON.stringify(systemPrompt)};const e=db.prepare("SELECT 1 FROM prompt_versions WHERE prompt_type=?").get(t);if(!e){db.prepare("INSERT INTO prompt_versions(prompt_type,version,content,created_by)VALUES(?,1,?,?)").run(t,c,"installer");console.log("Prompt seeded");}else{console.log("Prompt exists");}`);
+
+// --- Data files ---
+fs.writeFileSync(path.join(outputDir, "data", "vip-emails.json"), "[]");
+
+// --- HT/AT Task System ---
+const tasks = generateStarterTasks({
+  agentName, clawType,
+  senderEmail: config.senderEmail,
+  toolsUsed: config.toolsUsed,
+  autonomy: config.autonomy,
+  enableLocalSwarm: config.enableLocalSwarm,
+  enableGlobalSwarm: config.enableGlobalSwarm,
+  relayUrl: config.relayUrl,
+});
+fs.writeFileSync(path.join(outputDir, "data", "tasks.json"), JSON.stringify(tasks, null, 2));
+console.log(`  Generated ${tasks.human_tasks.length} starter HTs + ${tasks.ai_tasks.length} starter ATs`);
+
+// Swarm config
+const swarmConfig = {
+  agentName,
+  relayUrl: config.relayUrl || "http://localhost:7891",
+  enableLocal: config.enableLocalSwarm !== false,
+  enableGlobal: config.enableGlobalSwarm !== false,
+};
+fs.writeFileSync(path.join(outputDir, "data", "swarm-config.json"), JSON.stringify(swarmConfig, null, 2));
+
+// --- Desktop launcher ---
+fs.writeFileSync(path.join(outputDir, `Launch ${agentName}.bat`),
+  `@echo off\r\nstart "" cmd /k "cd /d ""${outputDir}"" && scripts\\launch.bat"\r\n`);
+
+// --- Open dashboard script ---
+fs.writeFileSync(path.join(outputDir, "scripts", "open-dashboard.bat"),
+  `@echo off\r\ncd /d "${outputDir}"\r\ncall npx tsx src/update-dashboard.ts 2>nul\r\nstart "" "${path.join(outputDir, "dashboard.html")}"\r\n`);
+
+// --- .gitignore ---
+fs.writeFileSync(path.join(outputDir, ".gitignore"), "node_modules/\ndist/\ndata/\n*.db\n.env\n");
+
+// --- Claude Code permissions (auto mode — no permission prompts) ---
+const claudeSettingsDir = path.join(outputDir, ".claude");
+fs.mkdirSync(claudeSettingsDir, { recursive: true });
+fs.writeFileSync(path.join(claudeSettingsDir, "settings.json"), JSON.stringify({
+  permissions: {
+    defaultMode: "auto",
+    allow: [
+      "Bash(npx *)", "Bash(npm *)", "Bash(node *)", "Bash(tsx *)",
+      "Bash(cd *)", "Bash(ls *)", "Bash(cat *)", "Bash(echo *)", "Bash(mkdir *)",
+      "Bash(curl *)", "Bash(git *)", "Bash(schtasks *)",
+      "Edit", "Read", "Glob", "Grep",
+      "WebFetch", "WebSearch"
+    ],
+    deny: [
+      "Bash(rm -rf /)",
+      "Bash(curl * | bash)",
+      "Bash(format *)"
+    ]
+  }
+}, null, 2));
+
+// --- Write modules.json ---
+writeModulesJson(outputDir, modulesToInstall);
+
+console.log(`\nScaffold complete — ${modulesToInstall.length} modules installed.`);
+console.log(`Modules: ${modulesToInstall.map(m => m.manifest.name).join(", ")}`);
+
+// --- System prompt builder ---
+function buildSystemPrompt(cfg: any): string {
+  const p = [`You are ${cfg.agentName || "Atlas"}, an autonomous AI agent.`, `Type: ${cfg.clawType || "custom"}`];
+  if (cfg.taskDescription) p.push("Task: " + cfg.taskDescription);
+  if (cfg.toolsUsed) p.push("Tools: " + cfg.toolsUsed);
+  if (cfg.autonomy === "supervised") p.push("Always suggest and wait for approval.");
+  if (cfg.autonomy === "full") p.push("Fully autonomous. Alert on errors only.");
+  if (cfg.autonomy === "semi") p.push("Act on routine. Ask on important.");
+  if (cfg.volume) p.push("Volume: " + cfg.volume);
+  if (cfg.specialInstructions) p.push("Special: " + cfg.specialInstructions);
+  if (cfg.clawType === "outreach") {
+    if (cfg.senderName) p.push("Send as: " + cfg.senderName);
+    if (cfg.senderEmail) p.push("From: " + cfg.senderEmail);
+    if (cfg.targetAudience) p.push("Target: " + cfg.targetAudience);
+    if (cfg.purpose) p.push("Goal: " + cfg.purpose);
+  }
+  p.push("\nRules:\n- Read data/state.json first\n- Update state.json last\n- Self-update AFTER tasks\n- Read SOUL.md for principles\n- Check QIS buckets before work, deposit after");
+  return p.join("\n");
+}

package/installer/task-generator.ts

@@ -0,0 +1,324 @@
+/**
+ * MetaClaw Task Generator
+ * Creates starter HT/AT tasks based on questionnaire answers.
+ * Called during scaffold to generate data/tasks.json.
+ */
+
+interface TaskConfig {
+  agentName: string;
+  clawType: string;
+  senderEmail?: string;
+  toolsUsed?: string;
+  autonomy?: string;
+  enableLocalSwarm?: boolean;
+  enableGlobalSwarm?: boolean;
+  relayUrl?: string;
+}
+
+export function generateStarterTasks(config: TaskConfig): any {
+  const relayUrl = config.relayUrl || "http://localhost:7891";
+  const hts: any[] = [];
+  const ats: any[] = [];
+  let htNum = 1;
+  let atNum = 1;
+
+  const ht = (data: any) => {
+    const id = `ht-${String(htNum++).padStart(3, "0")}`;
+    return { id, status: "pending", created_at: new Date().toISOString(), completed_at: null, created_by: "system", notes: null, ...data };
+  };
+
+  const at = (data: any) => {
+    const id = `at-${String(atNum++).padStart(3, "0")}`;
+    return { id, status: data.requires_ht ? "blocked" : "pending", created_at: new Date().toISOString(), created_by: "system", ...data };
+  };
+
+  // === UNIVERSAL HTs (every claw type) ===
+
+  hts.push(ht({
+    title: "Verify Claude Code is authenticated",
+    description: "Make sure Claude Code can connect to your account.",
+    priority: "critical", category: "auth",
+    blocks: [`at-${String(atNum).padStart(3, "0")}`],
+    instructions: [
+      "Open a terminal in this project directory",
+      "Run: claude --version",
+      "If it shows a version number, you're good",
+      "If not, run: claude auth login",
+      "Follow the browser prompts to authenticate"
+    ],
+    why: "The agent cannot function without Claude Code authentication. This is step zero.",
+    outcome: "Agent can start working autonomously.",
+    estimated_minutes: 2
+  }));
+
+  ats.push(at({
+    title: "Run first health check and status report",
+    priority: "critical", category: "setup",
+    requires_ht: ["ht-001"],
+    description: "Verify all systems are working after install."
+  }));
+
+  hts.push(ht({
+    title: "Review agent personality and instructions",
+    description: "Read CLAUDE.md and SOUL.md — customize if needed.",
+    priority: "high", category: "config",
+    blocks: [],
+    instructions: [
+      "Open CLAUDE.md in a text editor",
+      "Review the system prompt — does it match what you want?",
+      "Open SOUL.md — these are the agent's principles",
+      "Edit either file if you want to adjust behavior",
+      "Save and the agent will pick up changes next session"
+    ],
+    why: "The agent's personality and rules come from these files. Customizing them makes the agent truly yours.",
+    outcome: "Agent behavior matches your expectations.",
+    estimated_minutes: 5
+  }));
+
+  hts.push(ht({
+    title: "Set your timezone",
+    description: "Tell the agent your local timezone so it schedules correctly.",
+    priority: "high", category: "config",
+    blocks: [],
+    instructions: [
+      "Open data/state.json",
+      "Add or update the field: \"timezone\": \"America/Phoenix\" (or your timezone)",
+      "Save the file",
+      "Common values: America/New_York, America/Chicago, America/Denver, America/Los_Angeles, America/Phoenix (no DST)"
+    ],
+    why: "Without your timezone, the agent hallucinates times and schedules things at wrong hours.",
+    outcome: "Agent knows what time it is in your world.",
+    estimated_minutes: 1
+  }));
+
+  // === OUTREACH-SPECIFIC HTs ===
+  if (config.clawType === "outreach") {
+    const emailHtId = `ht-${String(htNum).padStart(3, "0")}`;
+    hts.push(ht({
+      title: "Create a dedicated outreach email account",
+      description: "Set up a separate Gmail for outreach. Never use your personal email — protects your main inbox from deliverability issues.",
+      priority: "critical", category: "auth",
+      blocks: [`at-${String(atNum + 1).padStart(3, "0")}`, `at-${String(atNum + 2).padStart(3, "0")}`],
+      instructions: [
+        "Go to accounts.google.com and create a new Google account",
+        "Use a professional address (e.g., yourname.outreach@gmail.com)",
+        "Enable 2-Step Verification: Security > 2-Step Verification",
+        "Generate an App Password: Security > 2-Step Verification > App passwords",
+        "Select 'Mail' and your device, click Generate",
+        "Copy the 16-character app password — you'll need it next"
+      ],
+      why: "Your agent sends emails from this account. A dedicated account protects your personal email reputation and lets the agent operate without risk to your main inbox.",
+      outcome: "Agent can send outreach emails autonomously.",
+      estimated_minutes: 10
+    }));
+
+    const credsHtId = `ht-${String(htNum).padStart(3, "0")}`;
+    hts.push(ht({
+      title: "Add email credentials to .env file",
+      description: "Enter your outreach Gmail and app password so the agent can send.",
+      priority: "critical", category: "auth",
+      depends_on_ht: [emailHtId],
+      status: "blocked",
+      blocks: [`at-${String(atNum + 1).padStart(3, "0")}`],
+      instructions: [
+        "Create a file called .env in the project root (if it doesn't exist)",
+        "Add these lines:",
+        "SMTP_HOST=smtp.gmail.com",
+        "SMTP_PORT=587",
+        `SMTP_USER=${config.senderEmail || "your.outreach@gmail.com"}`,
+        "SMTP_PASS=your-16-char-app-password",
+        "Save the file"
+      ],
+      deliver_to: ".env",
+      why: "The agent reads these credentials to connect to Gmail's SMTP server.",
+      outcome: "Agent can authenticate with Gmail and start sending emails.",
+      estimated_minutes: 2
+    }));
+
+    hts.push(ht({
+      title: "Provide initial prospect list or target description",
+      description: "Give the agent a starting point — who should it reach out to?",
+      priority: "high", category: "data",
+      blocks: [],
+      instructions: [
+        "Option A: Create data/prospects.csv with columns: name, email, company, role",
+        "Option B: Describe your ideal prospect in CLAUDE.md under 'Target Audience'",
+        "Option C: Just tell the agent in your first conversation who to target",
+        "Any of these works — the agent will refine from there"
+      ],
+      why: "The agent needs a starting direction. It can research and expand from any seed list.",
+      outcome: "Agent can start finding and qualifying prospects.",
+      estimated_minutes: 10
+    }));
+
+    hts.push(ht({
+      title: "Review and approve first batch of draft emails",
+      description: "Before the agent sends to real people, review its first drafts.",
+      priority: "high", category: "approval",
+      blocks: [],
+      instructions: [
+        "Run: npm run dry-run",
+        "Review the generated email drafts",
+        "Provide feedback on tone, length, personalization",
+        "When satisfied, tell the agent to go live"
+      ],
+      why: "First impressions matter. Reviewing early drafts catches issues before they reach real prospects.",
+      outcome: "Agent transitions from draft mode to live sending.",
+      estimated_minutes: 15
+    }));
+
+    ats.push(at({ title: "Send test email to operator's personal address", priority: "high", requires_ht: [credsHtId] }));
+    ats.push(at({ title: "Research first 20 prospects based on target description", priority: "high", requires_ht: [emailHtId] }));
+  }
+
+  // === RESEARCH-SPECIFIC HTs ===
+  if (config.clawType === "research") {
+    hts.push(ht({
+      title: "Define research scope and output format",
+      description: "Tell the agent what to research and how to deliver results.",
+      priority: "critical", category: "config",
+      blocks: [],
+      instructions: [
+        "Open CLAUDE.md",
+        "Under 'System Prompt', add a 'Research Scope' section",
+        "Define: what topics to research, how deep to go, what format for reports",
+        "Example: 'Research competitor pricing in the SaaS space. Output as markdown reports in data/reports/.'"
+      ],
+      why: "Without a clear scope, the agent will research broadly and waste tokens on irrelevant topics.",
+      outcome: "Agent produces focused, useful research reports.",
+      estimated_minutes: 10
+    }));
+
+    hts.push(ht({
+      title: "Set up web search API key (optional)",
+      description: "For deeper research, the agent can use Brave Search or similar APIs.",
+      priority: "normal", category: "auth",
+      blocks: [],
+      instructions: [
+        "Go to https://api.search.brave.com/ and create a free account",
+        "Generate an API key",
+        "Add to .env: BRAVE_SEARCH_API_KEY=your-key-here",
+        "This is optional — the agent can research without it, but results will be better with it"
+      ],
+      why: "API-powered search gives more structured, recent, and comprehensive results than scraping.",
+      outcome: "Agent research quality improves significantly.",
+      estimated_minutes: 5
+    }));
+  }
+
+  // === SUPPORT-SPECIFIC HTs ===
+  if (config.clawType === "support") {
+    hts.push(ht({
+      title: "Connect support inbox (IMAP credentials)",
+      description: "Give the agent access to the support email inbox.",
+      priority: "critical", category: "auth",
+      blocks: [],
+      instructions: [
+        "Add to .env:",
+        "IMAP_HOST=imap.gmail.com",
+        "IMAP_PORT=993",
+        "IMAP_USER=support@yourcompany.com",
+        "IMAP_PASS=your-app-password",
+        "Save the file"
+      ],
+      why: "The agent monitors this inbox for support tickets. Without access, it can't triage or respond.",
+      outcome: "Agent can read incoming support emails and start auto-triaging.",
+      estimated_minutes: 5
+    }));
+
+    hts.push(ht({
+      title: "Define escalation rules",
+      description: "Tell the agent when to handle tickets vs when to escalate to you.",
+      priority: "high", category: "config",
+      blocks: [],
+      instructions: [
+        "Open CLAUDE.md",
+        "Add an 'Escalation Rules' section",
+        "Define: what the agent can auto-resolve, what needs human review",
+        "Example: 'Auto-resolve password resets and how-to questions. Escalate billing disputes and anything mentioning legal.'"
+      ],
+      why: "Without clear rules, the agent either escalates everything (useless) or handles things it shouldn't (dangerous).",
+      outcome: "Agent handles routine tickets autonomously, escalates important ones.",
+      estimated_minutes: 10
+    }));
+  }
+
+  // === SOCIAL-SPECIFIC HTs ===
+  if (config.clawType === "social") {
+    hts.push(ht({
+      title: "Connect social media accounts",
+      description: "Provide API keys or credentials for the platforms you want to post on.",
+      priority: "critical", category: "auth",
+      blocks: [],
+      instructions: [
+        "For each platform you want the agent to post on:",
+        "LinkedIn: Create an app at linkedin.com/developers, get access token",
+        "Twitter/X: Create an app at developer.twitter.com, get API keys",
+        "Dev.to: Go to dev.to/settings/extensions, generate API key",
+        "Add each to .env: LINKEDIN_TOKEN=xxx, TWITTER_API_KEY=xxx, DEVTO_API_KEY=xxx"
+      ],
+      why: "The agent needs API access to post on your behalf.",
+      outcome: "Agent can publish content to your social channels.",
+      estimated_minutes: 20
+    }));
+
+    hts.push(ht({
+      title: "Define brand voice and content guidelines",
+      description: "Tell the agent what your brand sounds like.",
+      priority: "high", category: "config",
+      blocks: [],
+      instructions: [
+        "Open CLAUDE.md",
+        "Add a 'Brand Voice' section with:",
+        "- Tone (professional, casual, technical, friendly)",
+        "- Topics to cover and topics to avoid",
+        "- Example posts you like",
+        "- Any hashtags or formatting preferences"
+      ],
+      why: "Consistent brand voice builds audience trust. Without guidelines, the agent's content will feel generic.",
+      outcome: "Agent produces on-brand content that sounds like you.",
+      estimated_minutes: 15
+    }));
+  }
+
+  // === UNIVERSAL SETUP ATs ===
+  ats.push(at({ title: "Initialize database and seed config", priority: "critical", category: "setup" }));
+  ats.push(at({ title: "Generate initial dashboard", priority: "high", category: "setup" }));
+  ats.push(at({ title: "Set up scheduled cron tasks", priority: "high", category: "setup" }));
+
+  if (config.enableLocalSwarm !== false || config.enableGlobalSwarm !== false) {
+    ats.push(at({
+      title: "Register with global intelligence network (${relayUrl})",
+      priority: "critical",
+      category: "setup",
+      description: `Run: curl -s -X POST ${relayUrl}/nodes/register -H 'Content-Type: application/json' -d '{"node_id":"mc_anon_${config.agentName?.toLowerCase().replace(/[^a-z0-9]/g, '') || 'agent'}","agent_name":"${config.agentName || 'agent'}"}'`
+    }));
+    ats.push(at({
+      title: "Sync CAPABILITIES.md with auto-scanned inventory",
+      priority: "high",
+      category: "setup",
+      description: "Run: npm run scan — then read memory/capabilities/_auto.md and update memory/CAPABILITIES.md to match what actually exists"
+    }));
+    ats.push(at({
+      title: "Query global relay for insight on your agent type before first task",
+      priority: "high",
+      category: "setup",
+      description: `Run: curl -s ${relayUrl}/buckets?q=${config.clawType || 'agent'}`
+    }));
+  }
+
+  return {
+    version: "1.0.0",
+    agent_name: config.agentName,
+    template: config.clawType,
+    generated_at: new Date().toISOString(),
+    setup_progress: {
+      phase: "getting_started" as const,
+      total_ht: hts.length,
+      completed_ht: 0,
+      percent: 0,
+    },
+    human_tasks: hts,
+    ai_tasks: ats,
+  };
+}