clawcompany 0.1.0

package/dist/index.js

@@ -0,0 +1,1673 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils.ts
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+function banner() {
+  console.log("");
+  console.log("  \u{1F99E} ClawCompany v0.1.0");
+  console.log("  Build for OPC. Every human being is a chairman.");
+  console.log("");
+}
+function getConfigDir() {
+  const dir = join(process.env.HOME ?? "~", ".clawcompany");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function configExists() {
+  return existsSync(getConfigPath());
+}
+function readConfig() {
+  if (!configExists()) return null;
+  try {
+    return JSON.parse(readFileSync(getConfigPath(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2));
+}
+async function apiGet(path, port = 3200) {
+  const res = await fetch(`http://localhost:${port}${path}`);
+  if (!res.ok) throw new Error(`API error: ${res.status}`);
+  return res.json();
+}
+async function apiPost(path, body, port = 3200) {
+  const res = await fetch(`http://localhost:${port}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    throw new Error(err.error ?? `API error: ${res.status}`);
+  }
+  return res.json();
+}
+async function validateClawApiKey(key) {
+  try {
+    const res = await fetch("https://clawapi.org/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${key}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: "gpt-oss-20b",
+        messages: [{ role: "user", content: "hi" }],
+        max_tokens: 5
+      })
+    });
+    if (res.status === 401) return { valid: false, error: "Invalid key. Check your key at clawapi.org" };
+    if (!res.ok) return { valid: false, error: `ClawAPI returned ${res.status}. Try again later.` };
+    return { valid: true };
+  } catch (err) {
+    return { valid: false, error: `Cannot reach ClawAPI: ${err.message}. Check your internet connection.` };
+  }
+}
+async function isServerRunning(port = 3200) {
+  try {
+    const res = await fetch(`http://localhost:${port}/api/health`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../packages/shared/src/types.ts
+var init_types = __esm({
+  "../packages/shared/src/types.ts"() {
+    "use strict";
+  }
+});
+
+// ../packages/shared/src/defaults.ts
+function getDefaultConfig() {
+  const rolesMap = {};
+  for (const role2 of BUILTIN_ROLES) {
+    rolesMap[role2.id] = { model: role2.model, provider: role2.provider };
+  }
+  return {
+    version: "1.0",
+    providers: [DEFAULT_CLAWAPI_PROVIDER],
+    roles: rolesMap,
+    fallbackChain: DEFAULT_FALLBACK_CHAIN
+  };
+}
+function getBuiltinRole(id) {
+  return BUILTIN_ROLES.find((r) => r.id === id);
+}
+function resolveRoles(config) {
+  const resolved = [];
+  for (const [id, overrides] of Object.entries(config.roles)) {
+    const builtin = getBuiltinRole(id);
+    if (builtin) {
+      resolved.push({ ...builtin, ...overrides, id, isBuiltin: true, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    } else {
+      if (!overrides.name || !overrides.model) {
+        throw new Error(`Custom role "${id}" must have at least "name" and "model"`);
+      }
+      resolved.push({
+        id,
+        name: overrides.name,
+        description: overrides.description ?? "",
+        systemPrompt: overrides.systemPrompt ?? `You are ${overrides.name}.`,
+        model: overrides.model,
+        provider: overrides.provider ?? config.providers[0]?.id ?? "clawapi",
+        reportsTo: overrides.reportsTo ?? "ceo",
+        canDelegateTo: overrides.canDelegateTo ?? [],
+        canEscalateTo: overrides.canEscalateTo ?? [overrides.reportsTo ?? "ceo"],
+        budgetTier: overrides.budgetTier ?? "save",
+        budgetMonthly: overrides.budgetMonthly ?? null,
+        maxTokensPerTask: overrides.maxTokensPerTask ?? null,
+        tools: overrides.tools ?? ["filesystem", "http"],
+        skills: overrides.skills ?? [],
+        isBuiltin: false,
+        isActive: overrides.isActive ?? true,
+        heartbeatInterval: overrides.heartbeatInterval ?? 0,
+        createdAt: overrides.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  return resolved;
+}
+var DEFAULT_CLAWAPI_PROVIDER, BUILTIN_ROLES, DEFAULT_FALLBACK_CHAIN, MODEL_PRICING;
+var init_defaults = __esm({
+  "../packages/shared/src/defaults.ts"() {
+    "use strict";
+    DEFAULT_CLAWAPI_PROVIDER = {
+      id: "clawapi",
+      name: "ClawAPI",
+      type: "openai-compatible",
+      baseUrl: "https://clawapi.org/api/v1",
+      apiKey: "${CLAWAPI_KEY}",
+      isDefault: true,
+      models: "auto",
+      features: {
+        cryptoPayment: true,
+        multiModel: true,
+        autoFallback: true
+      }
+    };
+    BUILTIN_ROLES = [
+      // ═══ C-Suite ═══
+      {
+        id: "ceo",
+        name: "CEO",
+        description: "Top AI executive. Decomposes missions, coordinates departments, final quality gate.",
+        systemPrompt: `You are the CEO of this AI company. You report directly to the Chairman (the human).
+
+You are the highest-ranking AI executive. When the Chairman gives a mission, you decompose it into work streams, delegate to department heads, collect reports, review quality, and deliver the final result.
+
+DECOMPOSITION:
+1. What types of work does this mission require?
+2. Which roles are best suited for each work stream?
+3. What are the dependencies between work streams?
+4. What can be done in parallel?
+5. What is the estimated cost?
+
+DELEGATION:
+- Technical work \u2192 CTO or Engineer
+- Financial analysis \u2192 CFO or Analyst
+- Marketing, content \u2192 CMO
+- Research \u2192 Researcher
+- Data collection, formatting \u2192 Worker
+- Report formatting \u2192 Secretary
+- Your time is the most expensive \u2014 delegate everything you can
+
+COST AWARENESS:
+- A task a Worker can do for $0.003 should NOT be done by you for $0.10
+- Always assign to the cheapest role that can handle the task well`,
+        model: "claude-opus-4-6",
+        provider: "clawapi",
+        reportsTo: null,
+        canDelegateTo: ["cto", "cfo", "cmo", "researcher", "analyst", "engineer", "secretary", "worker"],
+        canEscalateTo: [],
+        budgetTier: "earn",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "cto",
+        name: "CTO",
+        description: "Technical architecture, code review, system design, technical decisions.",
+        systemPrompt: `You are the CTO. You report to the CEO.
+
+Own all technical decisions \u2014 architecture, system design, code review, security, performance. Delegate implementation to Engineers, routine data work to Workers.
+
+STANDARDS: Clean code, security-first, performance-aware, clear technical explanations.`,
+        model: "gpt-5.4",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: ["engineer", "worker"],
+        canEscalateTo: ["ceo"],
+        budgetTier: "earn",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["shell", "filesystem", "http", "code_interpreter"],
+        skills: ["coding"],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "cfo",
+        name: "CFO",
+        description: "Financial analysis, budgets, projections, cost optimization.",
+        systemPrompt: `You are the CFO. You report to the CEO.
+
+Handle all financial work \u2014 budget analysis, cost projections, financial modeling, ROI calculations. Think step by step through numbers. State assumptions. Present data in clear tables.`,
+        model: "gpt-5-mini",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: ["analyst", "worker"],
+        canEscalateTo: ["ceo"],
+        budgetTier: "save",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem", "code_interpreter"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "cmo",
+        name: "CMO",
+        description: "Marketing strategy, content creation, brand voice, growth.",
+        systemPrompt: `You are the CMO. You report to the CEO.
+
+Own marketing strategy, content creation, brand voice, growth initiatives. Write compelling copy, design campaigns, analyze market positioning. Punchy, engaging, brand-consistent.`,
+        model: "claude-sonnet-4-6",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: ["researcher", "worker"],
+        canEscalateTo: ["ceo"],
+        budgetTier: "earn",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      // ═══ Mid-level ═══
+      {
+        id: "researcher",
+        name: "Researcher",
+        description: "Deep research, source evaluation, competitive analysis.",
+        systemPrompt: `You are a Researcher. You report to whoever delegates to you.
+
+Conduct deep research \u2014 gather information, evaluate sources, analyze competitors, investigate topics thoroughly. Cite sources. Distinguish facts from opinions. Flag data gaps.`,
+        model: "claude-sonnet-4-6",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: ["worker"],
+        canEscalateTo: ["ceo"],
+        budgetTier: "earn",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "analyst",
+        name: "Analyst",
+        description: "Data analysis, pattern detection, metrics, quantitative work.",
+        systemPrompt: `You are an Analyst. You report to the CFO or CEO.
+
+Analyze data, detect patterns, calculate metrics, build models. Show calculations step by step. Present findings in tables. State assumptions. Quantify confidence levels.`,
+        model: "claude-sonnet-4-6",
+        provider: "clawapi",
+        reportsTo: "cfo",
+        canDelegateTo: ["worker"],
+        canEscalateTo: ["cfo"],
+        budgetTier: "save",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem", "code_interpreter"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "engineer",
+        name: "Engineer",
+        description: "Code implementation, debugging, testing, feature development.",
+        systemPrompt: `You are an Engineer. You report to the CTO.
+
+Write code, implement features, fix bugs, write tests. Execute the technical vision set by the CTO. Clean, readable code with error handling.`,
+        model: "gpt-5.4",
+        provider: "clawapi",
+        reportsTo: "cto",
+        canDelegateTo: ["worker"],
+        canEscalateTo: ["cto"],
+        budgetTier: "earn",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["shell", "filesystem", "http", "code_interpreter"],
+        skills: ["coding"],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "secretary",
+        name: "Secretary",
+        description: "Briefings, summaries, report formatting, document preparation.",
+        systemPrompt: `You are the Secretary. You report to the CEO.
+
+Prepare briefings, format reports, summarize documents, organize information. Make everything presentable for the Chairman (the human). Concise, professional, no fluff.`,
+        model: "gemini-3.1-flash-lite",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: [],
+        canEscalateTo: ["ceo"],
+        budgetTier: "save",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["http", "filesystem"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      // ═══ Operations ═══
+      {
+        id: "worker",
+        name: "Worker",
+        description: "Fast routine tasks, data collection, formatting, translation.",
+        systemPrompt: `You are a Worker. Execute routine tasks quickly and reliably. Data collection, formatting, translation, classification, tagging. Focus on speed and accuracy. Keep outputs structured.`,
+        model: "gemini-3.1-flash-lite",
+        provider: "clawapi",
+        reportsTo: "ceo",
+        canDelegateTo: [],
+        canEscalateTo: ["ceo"],
+        budgetTier: "save",
+        budgetMonthly: null,
+        maxTokensPerTask: null,
+        tools: ["filesystem", "http"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      // ═══ Fallback ═══
+      {
+        id: "fallback_a",
+        name: "Fallback A",
+        description: "Low-balance fallback.",
+        systemPrompt: `Fallback agent. Low-balance mode. Be concise. Output only what's needed.`,
+        model: "gpt-oss-120b",
+        provider: "clawapi",
+        reportsTo: null,
+        canDelegateTo: [],
+        canEscalateTo: [],
+        budgetTier: "survive",
+        budgetMonthly: null,
+        maxTokensPerTask: 2e3,
+        tools: ["filesystem"],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        id: "fallback_b",
+        name: "Fallback B",
+        description: "Minimum cost, last resort.",
+        systemPrompt: `Last-resort agent. Extremely low balance. Classification, tagging, yes/no only.`,
+        model: "gpt-oss-20b",
+        provider: "clawapi",
+        reportsTo: null,
+        canDelegateTo: [],
+        canEscalateTo: [],
+        budgetTier: "survive",
+        budgetMonthly: null,
+        maxTokensPerTask: 500,
+        tools: [],
+        skills: [],
+        isBuiltin: true,
+        isActive: true,
+        heartbeatInterval: 0,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ];
+    DEFAULT_FALLBACK_CHAIN = [
+      "claude-opus-4-6",
+      "claude-sonnet-4-6",
+      "gpt-5.4",
+      "gpt-5-mini",
+      "gemini-3.1-flash-lite",
+      "gpt-oss-120b",
+      "gpt-oss-20b"
+    ];
+    MODEL_PRICING = {
+      "claude-opus-4-6": { input: 5, output: 25 },
+      "claude-sonnet-4-6": { input: 3, output: 15 },
+      "gpt-5.4": { input: 2.5, output: 15 },
+      "gemini-3.1-pro": { input: 2, output: 12 },
+      "gpt-5-mini": { input: 0.25, output: 2 },
+      "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
+      "gpt-oss-120b": { input: 0.05, output: 0.45 },
+      "gpt-oss-20b": { input: 0.04, output: 0.18 }
+    };
+  }
+});
+
+// ../packages/shared/src/api-paths.ts
+var init_api_paths = __esm({
+  "../packages/shared/src/api-paths.ts"() {
+    "use strict";
+  }
+});
+
+// ../packages/shared/src/index.ts
+var init_src = __esm({
+  "../packages/shared/src/index.ts"() {
+    "use strict";
+    init_types();
+    init_defaults();
+    init_api_paths();
+  }
+});
+
+// src/commands/role.ts
+var role_exports = {};
+__export(role_exports, {
+  roleCommand: () => roleCommand,
+  roleListCommand: () => roleListCommand,
+  roleSetCommand: () => roleSetCommand
+});
+async function roleCommand() {
+  await roleListCommand();
+}
+async function roleListCommand() {
+  banner();
+  console.log("  \u{1F464} Chairman = Human (you)\n");
+  const config = readConfig();
+  const running = config ? await isServerRunning(config.serverPort) : false;
+  let roles;
+  if (running && config) {
+    try {
+      roles = await apiGet("/api/roles", config.serverPort);
+    } catch {
+      roles = BUILTIN_ROLES;
+    }
+  } else {
+    roles = BUILTIN_ROLES;
+  }
+  const active = roles.filter((r) => r.isActive && r.budgetTier !== "survive");
+  const inactive = roles.filter((r) => !r.isActive || r.budgetTier === "survive");
+  const maxName = Math.max(...active.map((r) => r.name.length));
+  const maxModel = Math.max(...active.map((r) => r.model.length));
+  for (const role2 of active) {
+    const pricing = MODEL_PRICING[role2.model];
+    const cost = pricing ? `$${pricing.input}/$${pricing.output}` : "";
+    const reports = role2.reportsTo ? `\u2192 ${role2.reportsTo}` : "\u2192 Human";
+    console.log(
+      `  ${role2.name.padEnd(maxName + 2)} ${role2.model.padEnd(maxModel + 2)} ${cost.padEnd(12)} reports ${reports}`
+    );
+  }
+  if (inactive.length > 0) {
+    console.log(`
+  + ${inactive.length} fallback/disabled roles`);
+  }
+  console.log("");
+  console.log("  Customize:");
+  console.log("    clawcompany role set cto --model deepseek-coder --provider deepseek");
+  console.log("");
+}
+async function roleSetCommand(roleId, opts) {
+  banner();
+  const role2 = BUILTIN_ROLES.find((r) => r.id === roleId);
+  if (!role2) {
+    console.log(`  \u2717 Role "${roleId}" not found.`);
+    console.log(`  Available: ${BUILTIN_ROLES.filter((r) => r.budgetTier !== "survive").map((r) => r.id).join(", ")}
+`);
+    return;
+  }
+  console.log(`  Role: ${role2.name} (${roleId})`);
+  console.log(`  Current model: ${role2.model}`);
+  if (opts.model) console.log(`  \u2192 New model: ${opts.model}`);
+  if (opts.provider) console.log(`  \u2192 New provider: ${opts.provider}`);
+  if (opts.name) console.log(`  \u2192 New name: ${opts.name}`);
+  console.log("");
+  console.log("  \u26A0 Hot-reload coming soon. For now, edit config and restart server.\n");
+}
+var init_role = __esm({
+  "src/commands/role.ts"() {
+    "use strict";
+    init_utils();
+    init_src();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+init_utils();
+init_src();
+import { input, select, confirm } from "@inquirer/prompts";
+async function initCommand() {
+  banner();
+  if (configExists()) {
+    const config2 = readConfig();
+    if (config2) {
+      console.log(`  \u2713 Company "${config2.companyName}" already exists.`);
+      console.log(`  \u2713 Config: ${getConfigDir()}/config.json`);
+      console.log("");
+      const reset = await confirm({
+        message: "Reset and start over?",
+        default: false
+      });
+      if (!reset) {
+        console.log("");
+        showNextSteps(config2.companyName);
+        return;
+      }
+      console.log("");
+    }
+  }
+  console.log("  Welcome! Let's set up your AI company.\n");
+  console.log("  Step 1/3: Connect to ClawAPI\n");
+  let apiKey = "";
+  let keyValid = false;
+  while (!keyValid) {
+    apiKey = await input({
+      message: "Enter your ClawAPI key:",
+      validate: (v) => {
+        if (!v.trim()) return "Key is required.";
+        if (!v.startsWith("sk-claw-")) return "Key should start with sk-claw-";
+        return true;
+      }
+    });
+    console.log("");
+    console.log("  Verifying key...");
+    const result = await validateClawApiKey(apiKey.trim());
+    if (result.valid) {
+      console.log("  \u2713 Key verified\n");
+      keyValid = true;
+    } else {
+      console.log(`  \u2717 ${result.error}`);
+      console.log("    Get a key at https://clawapi.org\n");
+    }
+  }
+  console.log("  Step 2/3: Name your company\n");
+  const companyName = await input({
+    message: "Company name:",
+    default: "My AI Company"
+  });
+  console.log("");
+  console.log("  Step 3/3: Choose a template\n");
+  const template = await select({
+    message: "Template:",
+    choices: [
+      {
+        name: "Default (CEO + CTO + CFO + CMO + Researcher + Analyst + Engineer + Secretary + Worker)",
+        value: "default"
+      },
+      {
+        name: "Trading Desk (+ Trader + Data Collector)",
+        value: "trading-desk"
+      },
+      {
+        name: "Content Agency (+ Writer + Editor + SEO)",
+        value: "content-agency"
+      },
+      {
+        name: "Dev Shop (+ QA + DevOps)",
+        value: "dev-shop"
+      },
+      {
+        name: "Solo Founder (CEO + Worker only \u2014 cheapest)",
+        value: "solo-founder"
+      }
+    ]
+  });
+  console.log("");
+  console.log("  Creating company...\n");
+  const config = {
+    apiKey: apiKey.trim(),
+    companyName,
+    template,
+    serverPort: 3200,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeConfig(config);
+  const roles = BUILTIN_ROLES.filter((r) => r.isActive && r.budgetTier !== "survive");
+  console.log(`  \u2713 Company "${companyName}" created`);
+  console.log(`  \u2713 ${roles.length} agents hired:
+`);
+  const maxName = Math.max(...roles.map((r) => r.name.length));
+  for (const role2 of roles) {
+    const pricing = MODEL_PRICING[role2.model];
+    const cost = pricing ? `$${pricing.input}/$${pricing.output}` : "";
+    console.log(`     ${role2.name.padEnd(maxName + 2)}\u2192 ${role2.model} (${cost})`);
+  }
+  console.log("");
+  console.log(`  \u2713 Config saved to ${getConfigDir()}/config.json`);
+  console.log("");
+  showNextSteps(companyName);
+}
+function showNextSteps(companyName) {
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  console.log(`  "${companyName}" is ready! You are the Chairman.
+`);
+  console.log("  Try:\n");
+  console.log('    clawcompany mission "Write a competitive analysis of OpenAI vs Anthropic"');
+  console.log("    clawcompany status");
+  console.log("    clawcompany role list");
+  console.log("");
+  console.log("  Build for OPC. Every human being is a chairman.");
+  console.log("");
+}
+
+// src/commands/mission.ts
+init_utils();
+init_src();
+
+// ../packages/providers/src/pricing.ts
+init_src();
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) return 0;
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  return Math.round((inputCost + outputCost) * 1e6) / 1e6;
+}
+
+// ../packages/providers/src/openai-compatible.ts
+var OpenAICompatibleProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.id = config.id;
+    this.name = config.name;
+    this.baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+    this.apiKey = config.apiKey;
+    if (Array.isArray(config.models)) {
+      for (const m of config.models) {
+        this.knownModels.add(m.id);
+      }
+    }
+  }
+  id;
+  name;
+  baseUrl;
+  apiKey;
+  knownModels = /* @__PURE__ */ new Set();
+  async chat(params) {
+    const url = `${this.baseUrl}/chat/completions`;
+    const isReasoning = this.isReasoningModel(params.model);
+    const body = {
+      model: params.model,
+      messages: params.messages,
+      max_tokens: params.maxTokens ?? 4096,
+      stream: true
+    };
+    if (!isReasoning) {
+      body.temperature = params.temperature ?? 0.7;
+    }
+    if (params.tools?.length) {
+      body.tools = params.tools;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e5);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        throw new ProviderError(
+          response.status,
+          `${this.name} API error ${response.status}: ${errorBody}`,
+          this.id
+        );
+      }
+      return await this.collectStream(response, params.model);
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") {
+        throw new ProviderError(
+          504,
+          `${this.name}: request timed out after 5 minutes for model ${params.model}`,
+          this.id
+        );
+      }
+      throw err;
+    }
+  }
+  /**
+   * Read SSE stream, accumulate content and tool calls.
+   */
+  async collectStream(response, model) {
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let content = "";
+    let finishReason = "stop";
+    let toolCalls = [];
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let actualModel = model;
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "data: [DONE]") continue;
+        if (!trimmed.startsWith("data: ")) continue;
+        try {
+          const json = JSON.parse(trimmed.slice(6));
+          const delta = json.choices?.[0]?.delta;
+          const choice = json.choices?.[0];
+          if (delta?.content) {
+            content += delta.content;
+          }
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCalls[idx]) {
+                toolCalls[idx] = {
+                  id: tc.id ?? "",
+                  type: "function",
+                  function: { name: "", arguments: "" }
+                };
+              }
+              if (tc.id) toolCalls[idx].id = tc.id;
+              if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
+            }
+          }
+          if (choice?.finish_reason) {
+            finishReason = choice.finish_reason;
+          }
+          if (json.model) {
+            actualModel = json.model;
+          }
+          if (json.usage) {
+            inputTokens = json.usage.prompt_tokens ?? 0;
+            outputTokens = json.usage.completion_tokens ?? 0;
+          }
+        } catch {
+        }
+      }
+    }
+    if (outputTokens === 0 && content.length > 0) {
+      outputTokens = Math.ceil(content.length / 4);
+    }
+    const validToolCalls = toolCalls.filter((tc) => tc.id && tc.function.name);
+    return {
+      content,
+      model: actualModel,
+      provider: this.id,
+      usage: {
+        inputTokens,
+        outputTokens,
+        cost: calculateCost(model, inputTokens, outputTokens)
+      },
+      toolCalls: validToolCalls.length > 0 ? validToolCalls : void 0,
+      finishReason
+    };
+  }
+  /**
+   * Reasoning models reject temperature parameter.
+   */
+  isReasoningModel(model) {
+    const reasoning = ["gpt-5-mini", "o1", "o1-mini", "o1-preview", "o3", "o3-mini"];
+    return reasoning.some((r) => model.includes(r));
+  }
+  async listModels() {
+    if (Array.isArray(this.config.models)) {
+      return this.config.models;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: { "Authorization": `Bearer ${this.apiKey}` }
+      });
+      if (!response.ok) return [];
+      const data = await response.json();
+      const models = (data.data ?? []).map((m) => ({
+        id: m.id,
+        name: m.id,
+        provider: this.id
+      }));
+      for (const m of models) {
+        this.knownModels.add(m.id);
+      }
+      return models;
+    } catch {
+      return [];
+    }
+  }
+  hasModel(modelId) {
+    return this.knownModels.has(modelId);
+  }
+  async healthCheck() {
+    try {
+      const models = await this.listModels();
+      return { ok: models.length > 0 };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+var ProviderError = class extends Error {
+  constructor(status, message, providerId) {
+    super(message);
+    this.status = status;
+    this.providerId = providerId;
+    this.name = "ProviderError";
+  }
+};
+
+// ../packages/providers/src/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  defaultProviderId = null;
+  /**
+   * Load providers from config. Call once at startup.
+   */
+  async loadFromConfig(configs) {
+    for (const config of configs) {
+      const resolvedConfig = {
+        ...config,
+        apiKey: this.resolveEnvVar(config.apiKey)
+      };
+      const provider = this.createProvider(resolvedConfig);
+      this.providers.set(config.id, provider);
+      if (config.isDefault) {
+        this.defaultProviderId = config.id;
+      }
+      if (config.models === "auto") {
+        await provider.listModels();
+      }
+    }
+    if (!this.defaultProviderId && configs.length > 0) {
+      this.defaultProviderId = configs[0].id;
+    }
+  }
+  /**
+   * Get a specific provider by ID, or the default.
+   */
+  get(id) {
+    if (id) {
+      const p = this.providers.get(id);
+      if (p) return p;
+    }
+    if (this.defaultProviderId) {
+      const p = this.providers.get(this.defaultProviderId);
+      if (p) return p;
+    }
+    throw new Error("No providers configured. Run `clawcompany init` first.");
+  }
+  /**
+   * Get the default provider (ClawAPI if configured).
+   */
+  getDefault() {
+    return this.get(this.defaultProviderId ?? void 0);
+  }
+  /**
+   * Find the first provider that serves a given model.
+   * Prefers the default provider if it has the model.
+   */
+  findProviderForModel(modelId) {
+    if (this.defaultProviderId) {
+      const def = this.providers.get(this.defaultProviderId);
+      if (def?.hasModel(modelId)) return def;
+    }
+    for (const [, provider] of this.providers) {
+      if (provider.hasModel(modelId)) return provider;
+    }
+    return null;
+  }
+  /**
+   * Hot-add a provider without restart.
+   */
+  async add(config) {
+    const resolvedConfig = {
+      ...config,
+      apiKey: this.resolveEnvVar(config.apiKey)
+    };
+    const provider = this.createProvider(resolvedConfig);
+    if (config.models === "auto") {
+      await provider.listModels();
+    }
+    this.providers.set(config.id, provider);
+  }
+  /**
+   * Remove a provider.
+   */
+  remove(id) {
+    if (id === this.defaultProviderId) {
+      throw new Error("Cannot remove the default provider. Set another as default first.");
+    }
+    return this.providers.delete(id);
+  }
+  /**
+   * List all registered providers.
+   */
+  list() {
+    return Array.from(this.providers.entries()).map(([id, p]) => ({
+      id,
+      name: p.name,
+      isDefault: id === this.defaultProviderId
+    }));
+  }
+  /**
+   * Iterate over all provider entries.
+   */
+  entries() {
+    return this.providers.entries();
+  }
+  // ──────────────────────────────────────────
+  // Internal
+  // ──────────────────────────────────────────
+  createProvider(config) {
+    switch (config.type) {
+      case "openai-compatible":
+      case "openai":
+      case "anthropic":
+      case "google-genai":
+        return new OpenAICompatibleProvider(config);
+      default:
+        return new OpenAICompatibleProvider(config);
+    }
+  }
+  /**
+   * Resolve ${ENV_VAR} patterns in config values.
+   */
+  resolveEnvVar(value) {
+    const match = value.match(/^\$\{(\w+)\}$/);
+    if (match) {
+      return process.env[match[1]] ?? value;
+    }
+    return value;
+  }
+};
+
+// ../packages/model-router/src/index.ts
+init_src();
+var ModelRouter = class {
+  constructor(registry, config) {
+    this.registry = registry;
+    this.config = config;
+    this.roles = resolveRoles(config);
+    this.fallbackChain = config.fallbackChain ?? DEFAULT_FALLBACK_CHAIN;
+  }
+  roles;
+  fallbackChain;
+  /**
+   * Send a chat request as a specific role.
+   * Automatically prepends the role's system prompt.
+   */
+  async chatAsRole(roleId, messages, tools) {
+    const role2 = this.roles.find((r) => r.id === roleId);
+    if (!role2) throw new Error(`Role "${roleId}" not found`);
+    if (!role2.isActive) throw new Error(`Role "${roleId}" is disabled`);
+    const hasSystem = messages.some((m) => m.role === "system");
+    const fullMessages = hasSystem ? messages : [{ role: "system", content: role2.systemPrompt }, ...messages];
+    const provider = this.registry.get(role2.provider);
+    try {
+      return await provider.chat({
+        model: role2.model,
+        messages: fullMessages,
+        tools
+      });
+    } catch (err) {
+      if (err && typeof err === "object" && "status" in err) {
+        if (err.status === 402) {
+          console.warn(`[ModelRouter] ${role2.name}: balance empty, falling back`);
+          return this.fallback(fullMessages, tools);
+        }
+        if (err.status === 429) {
+          console.warn(`[ModelRouter] ${role2.name}: rate limited, retrying in 2s`);
+          await sleep(2e3);
+          return provider.chat({ model: role2.model, messages: fullMessages, tools });
+        }
+        if (err.status === 502 || err.status === 503) {
+          console.warn(`[ModelRouter] ${role2.name}: upstream down, retrying in 3s`);
+          await sleep(3e3);
+          return provider.chat({ model: role2.model, messages: fullMessages, tools });
+        }
+      }
+      throw err;
+    }
+  }
+  async fallback(messages, tools) {
+    for (const modelId of this.fallbackChain) {
+      const provider = this.registry.findProviderForModel(modelId);
+      if (!provider) continue;
+      try {
+        const result = await provider.chat({ model: modelId, messages, tools });
+        console.log(`[ModelRouter] Fell back to ${modelId} via ${provider.name}`);
+        return result;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(
+      "All models in the fallback chain failed. Please check your balance at clawapi.org or add another provider."
+    );
+  }
+  getStrategyMode(balance) {
+    if (balance > 5) return "earn";
+    if (balance > 1) return "save";
+    return "survive";
+  }
+  setRoleModel(roleId, model, provider) {
+    const role2 = this.roles.find((r) => r.id === roleId);
+    if (!role2) throw new Error(`Role "${roleId}" not found`);
+    role2.model = model;
+    if (provider) role2.provider = provider;
+    role2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  getRoles() {
+    return this.roles;
+  }
+  getRole(id) {
+    return this.roles.find((r) => r.id === id);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// ../packages/tools/src/executor.ts
+import { exec } from "child_process";
+import { readFile, writeFile, readdir, unlink } from "fs/promises";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var ToolExecutor = class {
+  async execute(toolName, args) {
+    switch (toolName) {
+      case "filesystem":
+        return this.execFilesystem(args);
+      case "shell":
+        return this.execShell(args);
+      case "http":
+        return this.execHttp(args);
+      case "code_interpreter":
+        return this.execCode(args);
+      default:
+        return `Unknown tool: ${toolName}`;
+    }
+  }
+  async execFilesystem(args) {
+    const { action, path, content } = args;
+    switch (action) {
+      case "read":
+        return readFile(path, "utf-8");
+      case "write":
+        await writeFile(path, content ?? "");
+        return `Written to ${path}`;
+      case "list":
+        return (await readdir(path)).join("\n");
+      case "delete":
+        await unlink(path);
+        return `Deleted ${path}`;
+      default:
+        return `Unknown filesystem action: ${action}`;
+    }
+  }
+  async execShell(args) {
+    const { command, cwd } = args;
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
+        timeout: 3e4
+      });
+      return stdout + (stderr ? `
+STDERR: ${stderr}` : "");
+    } catch (err) {
+      return `Error: ${err.message}`;
+    }
+  }
+  async execHttp(args) {
+    const { method, url, headers, body } = args;
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: method !== "GET" ? body : void 0
+    });
+    const text = await response.text();
+    return `${response.status} ${response.statusText}
+${text.slice(0, 5e3)}`;
+  }
+  async execCode(args) {
+    const { language, code } = args;
+    if (language === "javascript") {
+      try {
+        const result = new Function(code)();
+        return String(result ?? "undefined");
+      } catch (err) {
+        return `Error: ${err.message}`;
+      }
+    }
+    if (language === "python") {
+      return this.execShell({ command: `python3 -c ${JSON.stringify(code)}` });
+    }
+    return `Unsupported language: ${language}`;
+  }
+};
+
+// ../packages/tools/src/index.ts
+var BUILTIN_TOOLS = {
+  filesystem: {
+    type: "function",
+    function: {
+      name: "filesystem",
+      description: "Read or write files. Actions: read, write, list, delete.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["read", "write", "list", "delete"] },
+          path: { type: "string", description: "File or directory path" },
+          content: { type: "string", description: "Content to write (for write action)" }
+        },
+        required: ["action", "path"]
+      }
+    }
+  },
+  shell: {
+    type: "function",
+    function: {
+      name: "shell",
+      description: "Execute a shell command and return stdout/stderr.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute" },
+          cwd: { type: "string", description: "Working directory (optional)" }
+        },
+        required: ["command"]
+      }
+    }
+  },
+  http: {
+    type: "function",
+    function: {
+      name: "http",
+      description: "Make an HTTP request. Supports GET, POST, PUT, DELETE.",
+      parameters: {
+        type: "object",
+        properties: {
+          method: { type: "string", enum: ["GET", "POST", "PUT", "DELETE"] },
+          url: { type: "string", description: "Request URL" },
+          headers: { type: "object", description: "Request headers" },
+          body: { type: "string", description: "Request body (for POST/PUT)" }
+        },
+        required: ["method", "url"]
+      }
+    }
+  },
+  code_interpreter: {
+    type: "function",
+    function: {
+      name: "code_interpreter",
+      description: "Execute JavaScript or Python code in a sandboxed environment.",
+      parameters: {
+        type: "object",
+        properties: {
+          language: { type: "string", enum: ["javascript", "python"] },
+          code: { type: "string", description: "Code to execute" }
+        },
+        required: ["language", "code"]
+      }
+    }
+  }
+};
+function getToolsForRole(toolNames) {
+  return toolNames.map((name) => BUILTIN_TOOLS[name]).filter((t) => t !== void 0);
+}
+
+// ../packages/agent-runtime/src/executor.ts
+var AgentExecutor = class {
+  constructor(router, toolExecutor) {
+    this.router = router;
+    this.toolExecutor = toolExecutor;
+  }
+  async execute(role2, task) {
+    const tools = getToolsForRole(role2.tools);
+    let totalIn = 0;
+    let totalOut = 0;
+    let totalCost = 0;
+    let toolCallCount = 0;
+    const messages = [
+      { role: "system", content: role2.systemPrompt },
+      {
+        role: "user",
+        content: this.buildTaskPrompt(task)
+      }
+    ];
+    const MAX_TURNS = 10;
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+      const response = await this.router.chatAsRole(
+        role2.id,
+        messages,
+        tools.length > 0 ? tools : void 0
+      );
+      totalIn += response.usage.inputTokens;
+      totalOut += response.usage.outputTokens;
+      totalCost += response.usage.cost;
+      if (!response.toolCalls?.length || response.finishReason === "stop") {
+        return {
+          output: response.content,
+          tokensIn: totalIn,
+          tokensOut: totalOut,
+          cost: totalCost,
+          modelUsed: response.model,
+          toolCallCount
+        };
+      }
+      messages.push({
+        role: "assistant",
+        content: response.content ?? "",
+        toolCalls: response.toolCalls
+      });
+      for (const toolCall of response.toolCalls) {
+        toolCallCount++;
+        const args = JSON.parse(toolCall.function.arguments);
+        const result = await this.toolExecutor.execute(
+          toolCall.function.name,
+          args
+        );
+        messages.push({
+          role: "tool",
+          content: result,
+          toolCallId: toolCall.id
+        });
+      }
+    }
+    return {
+      output: "[Agent reached maximum turns without completing]",
+      tokensIn: totalIn,
+      tokensOut: totalOut,
+      cost: totalCost,
+      modelUsed: role2.model,
+      toolCallCount
+    };
+  }
+  buildTaskPrompt(task) {
+    let prompt = `## Task: ${task.title}
+
+${task.description}`;
+    if (task.context) {
+      prompt += `
+
+## Context
+${JSON.stringify(task.context, null, 2)}`;
+    }
+    prompt += `
+
+## Instructions
+Complete this task. If you need to use tools, use them.
+When done, provide your final output clearly.
+Report any issues or blockers you encountered.`;
+    return prompt;
+  }
+};
+
+// ../packages/task-orchestrator/src/index.ts
+var TaskOrchestrator = class {
+  constructor(router) {
+    this.router = router;
+    this.executor = new AgentExecutor(router, new ToolExecutor());
+  }
+  executor;
+  /**
+   * Phase 2: CEO decomposes mission into work streams.
+   * Human (Chairman) gives the mission → CEO breaks it down.
+   */
+  async decompose(mission) {
+    const ceo = this.router.getRole("ceo");
+    if (!ceo) throw new Error("CEO role not configured");
+    const roles = this.router.getRoles().filter((r) => r.isActive && r.id !== "ceo" && r.budgetTier !== "survive");
+    const roleList = roles.map((r) => `- ${r.id}: ${r.name} (${r.model}) \u2014 ${r.description}`).join("\n");
+    const response = await this.router.chatAsRole("ceo", [
+      {
+        role: "user",
+        content: `Mission from the Chairman (human):
+"${mission.content}"
+
+Priority: ${mission.priority}
+${mission.deadline ? `Deadline: ${mission.deadline}` : ""}
+${mission.budgetLimit ? `Budget limit: $${mission.budgetLimit}` : ""}
+
+Your team:
+${roleList}
+
+Decompose into work streams. For each, specify:
+- id (ws_1, ws_2, ...)
+- title
+- description (specific deliverable)
+- assignTo (role id from list)
+- dependencies (array of ws IDs this depends on)
+- estimatedComplexity (low/medium/high)
+- requiredTools (array)
+
+IMPORTANT: Assign grunt work to worker (cheap). Technical to cto/engineer. Financial to cfo/analyst. Marketing to cmo. Research to researcher. Format to secretary.
+
+Respond ONLY with JSON:
+{
+  "workStreams": [ { "id": "ws_1", "title": "...", "description": "...", "assignTo": "worker", "dependencies": [], "estimatedComplexity": "low", "requiredTools": ["http"] } ]
+}`
+      }
+    ]);
+    try {
+      const cleaned = response.content.replace(/```json\n?/g, "").replace(/```/g, "").trim();
+      const parsed = JSON.parse(cleaned);
+      return (parsed.workStreams ?? []).map((ws) => ({
+        ...ws,
+        missionId: mission.id,
+        status: "pending"
+      }));
+    } catch {
+      return [{
+        id: "ws_1",
+        missionId: mission.id,
+        title: mission.content.slice(0, 100),
+        description: mission.content,
+        assignTo: "researcher",
+        dependencies: [],
+        estimatedComplexity: "medium",
+        requiredTools: [],
+        status: "pending"
+      }];
+    }
+  }
+  async executeMission(mission, workStreams) {
+    const results = /* @__PURE__ */ new Map();
+    const totalStart = Date.now();
+    let totalCost = 0;
+    const order = this.topologicalSort(workStreams);
+    console.log(`
+  \u{1F4CB} Executing ${order.length} work streams...
+`);
+    for (const ws of order) {
+      const depOutputs = {};
+      for (const depId of ws.dependencies) {
+        const dep = results.get(depId);
+        if (dep && dep.status === "completed") depOutputs[depId] = dep.output;
+      }
+      const role2 = this.router.getRole(ws.assignTo);
+      const roleName = role2?.name ?? ws.assignTo;
+      const modelName = role2?.model ?? "unknown";
+      console.log(`  \u26A1 ${ws.id}: ${ws.title}`);
+      console.log(`     \u2192 ${roleName} (${modelName})`);
+      const startTime = Date.now();
+      try {
+        const output = await this.executeWorkStream(ws, depOutputs);
+        const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+        results.set(ws.id, {
+          workStreamId: ws.id,
+          title: ws.title,
+          assignedTo: ws.assignTo,
+          output: output.content,
+          cost: output.cost,
+          tokensIn: output.tokensIn,
+          tokensOut: output.tokensOut,
+          model: output.model,
+          status: "completed"
+        });
+        totalCost += output.cost;
+        console.log(`     \u2705 Done (${elapsed}s, $${output.cost.toFixed(4)})
+`);
+      } catch (err) {
+        console.log(`     \u274C Failed: ${err.message}
+`);
+        results.set(ws.id, {
+          workStreamId: ws.id,
+          title: ws.title,
+          assignedTo: ws.assignTo,
+          output: `Error: ${err.message}`,
+          cost: 0,
+          tokensIn: 0,
+          tokensOut: 0,
+          model: "none",
+          status: "failed"
+        });
+      }
+    }
+    const totalElapsed = ((Date.now() - totalStart) / 1e3).toFixed(1);
+    console.log(`  \u{1F4CA} All work streams complete: ${totalElapsed}s, $${totalCost.toFixed(4)} total
+`);
+    return {
+      missionId: mission.id,
+      mission: mission.content,
+      workStreams: Array.from(results.values()),
+      totalCost,
+      totalTimeSeconds: parseFloat(totalElapsed)
+    };
+  }
+  async executeWorkStream(ws, dependencyOutputs) {
+    let context = "";
+    if (Object.keys(dependencyOutputs).length > 0) {
+      context = "\n\n## Previous work stream outputs:\n";
+      for (const [id, output] of Object.entries(dependencyOutputs)) {
+        const truncated = output.length > 500 ? output.slice(0, 500) + "\n...(truncated)" : output;
+        context += `
+### ${id}:
+${truncated}
+`;
+      }
+    }
+    const response = await this.router.chatAsRole(ws.assignTo, [
+      {
+        role: "user",
+        content: `## Task: ${ws.title}
+
+${ws.description}
+
+Complexity: ${ws.estimatedComplexity}${context}
+
+Today's date is ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}. Complete this task. Provide your output clearly and concisely.`
+      }
+    ]);
+    return {
+      content: response.content,
+      cost: response.usage.cost,
+      tokensIn: response.usage.inputTokens,
+      tokensOut: response.usage.outputTokens,
+      model: response.model
+    };
+  }
+  topologicalSort(workStreams) {
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const wsMap = new Map(workStreams.map((ws) => [ws.id, ws]));
+    const visit = (ws) => {
+      if (visited.has(ws.id)) return;
+      visited.add(ws.id);
+      for (const depId of ws.dependencies) {
+        const dep = wsMap.get(depId);
+        if (dep) visit(dep);
+      }
+      sorted.push(ws);
+    };
+    for (const ws of workStreams) visit(ws);
+    return sorted;
+  }
+};
+
+// src/commands/mission.ts
+async function missionCommand(goal) {
+  banner();
+  const config = readConfig();
+  if (!config) {
+    console.log("  \u2717 No company set up yet.");
+    console.log("  Fix: Run `npx clawcompany` to get started.\n");
+    return;
+  }
+  console.log(`  \u{1F3AF} Mission: "${goal}"
+`);
+  if (await isServerRunning(config.serverPort)) {
+    await runViaServer(goal, config.serverPort);
+  } else {
+    await runInProcess(goal, config.apiKey);
+  }
+}
+async function runViaServer(goal, port) {
+  console.log("  Sending to CEO...\n");
+  try {
+    const result = await apiPost("/api/mission/run", { mission: goal }, port);
+    if (result.status !== "completed") {
+      console.log(`  \u2717 Mission failed: ${result.error ?? "Unknown error"}`);
+      console.log("  Fix: Check server logs or retry.\n");
+      return;
+    }
+    printResults(result);
+  } catch (err) {
+    console.log(`  \u2717 ${err.message}
+`);
+  }
+}
+async function runInProcess(goal, apiKey) {
+  console.log("  Running in-process (no server needed)...\n");
+  try {
+    const clawConfig = getDefaultConfig();
+    clawConfig.providers[0].apiKey = apiKey;
+    const registry = new ProviderRegistry();
+    await registry.loadFromConfig(clawConfig.providers);
+    const router = new ModelRouter(registry, clawConfig);
+    const orchestrator = new TaskOrchestrator(router);
+    console.log("  Phase 2: CEO decomposing...");
+    const mission = {
+      id: `mission-${Date.now()}`,
+      companyId: "default",
+      content: goal,
+      status: "decomposing",
+      priority: "normal",
+      approvalRequired: false,
+      totalCost: 0,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const workStreams = await orchestrator.decompose(mission);
+    console.log(`  \u2705 Decomposed into ${workStreams.length} work streams
+`);
+    console.log("  Phase 3-5: Executing...");
+    const report = await orchestrator.executeMission(mission, workStreams);
+    console.log("  Phase 6: Delivering to Chairman\n");
+    const result = {
+      status: "completed",
+      mission: report.mission,
+      totalCost: `$${report.totalCost.toFixed(4)}`,
+      totalTime: `${report.totalTimeSeconds}s`,
+      workStreams: report.workStreams.map((ws) => ({
+        id: ws.workStreamId,
+        title: ws.title,
+        role: ws.assignedTo,
+        model: ws.model,
+        status: ws.status,
+        cost: `$${ws.cost.toFixed(4)}`,
+        outputPreview: ws.output.slice(0, 300) + (ws.output.length > 300 ? "..." : "")
+      }))
+    };
+    printResults(result);
+  } catch (err) {
+    console.log(`  \u2717 ${err.message}`);
+    console.log("  Fix: Check your ClawAPI key or internet connection.\n");
+  }
+}
+function printResults(result) {
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  console.log("  \u{1F4CB} Mission complete!\n");
+  for (const ws of result.workStreams) {
+    const icon = ws.status === "completed" ? "\u2705" : "\u274C";
+    console.log(`  ${icon} ${ws.title}`);
+    console.log(`     Role: ${ws.role} (${ws.model})`);
+    console.log(`     Cost: ${ws.cost}`);
+    if (ws.outputPreview) {
+      const preview = ws.outputPreview.slice(0, 120).replace(/\n/g, " ");
+      console.log(`     Preview: ${preview}...`);
+    }
+    console.log("");
+  }
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  console.log(`  Total cost: ${result.totalCost}`);
+  console.log(`  Total time: ${result.totalTime}`);
+  console.log(`  Work streams: ${result.workStreams.length}`);
+  console.log("");
+  console.log("  You are the Chairman. Approve, revise, or override.");
+  console.log("");
+}
+
+// src/commands/status.ts
+init_utils();
+async function statusCommand() {
+  banner();
+  const config = readConfig();
+  if (!config) {
+    console.log("  \u2717 No company set up yet.");
+    console.log("  Fix: Run `npx clawcompany` to get started.\n");
+    return;
+  }
+  console.log(`  Company: ${config.companyName}`);
+  console.log(`  Template: ${config.template}`);
+  console.log(`  Created: ${new Date(config.createdAt).toLocaleDateString()}`);
+  console.log("");
+  const running = await isServerRunning(config.serverPort);
+  if (running) {
+    console.log(`  \u2713 Server running at http://localhost:${config.serverPort}`);
+    try {
+      const roles = await apiGet("/api/roles", config.serverPort);
+      const active = roles.filter((r) => r.isActive && r.budgetTier !== "survive");
+      console.log(`  \u2713 ${active.length} active roles
+`);
+      const maxName = Math.max(...active.map((r) => r.name.length));
+      for (const role2 of active) {
+        console.log(`     ${role2.name.padEnd(maxName + 2)}\u2192 ${role2.model}`);
+      }
+      console.log("");
+    } catch {
+      console.log("  \u26A0 Could not fetch roles.\n");
+    }
+  } else {
+    console.log(`  \u2717 Server not running.`);
+    console.log(`  Fix: Run \`clawcompany\` to start.
+`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("clawcompany").description("Build for OPC. Every human being is a chairman.").version("0.1.0");
+program.command("init", { isDefault: true }).description("Set up your AI company (runs automatically on first use)").action(initCommand);
+program.command("mission <goal>").description("Give your company a mission").option("-t, --template <name>", "Override decomposition template").action(missionCommand);
+program.command("status").description("Check company status and active missions").action(statusCommand);
+var role = program.command("role").description("Manage roles");
+role.command("list").description("List all roles and their model bindings").action(async () => {
+  const { roleListCommand: roleListCommand2 } = await Promise.resolve().then(() => (init_role(), role_exports));
+  await roleListCommand2();
+});
+role.command("set <roleId>").description("Modify a role").option("-m, --model <model>", "Set model").option("-p, --provider <provider>", "Set provider").option("-n, --name <name>", "Set display name").action(async (roleId, opts) => {
+  const { roleSetCommand: roleSetCommand2 } = await Promise.resolve().then(() => (init_role(), role_exports));
+  await roleSetCommand2(roleId, opts);
+});
+program.parse();