@a-company/paradigm 1.5.0

package/dist/chunk-UM54F7G5.js

@@ -0,0 +1,1533 @@
+#!/usr/bin/env node
+import {
+  BackgroundOrchestrator
+} from "./chunk-AD2LSCHB.js";
+import {
+  AGENT_MODEL_RECOMMENDATIONS,
+  addActivity,
+  agentsConfigured,
+  clearCurrentAgent,
+  generateDefaultManifest,
+  getAgentsPath,
+  getParadigmDir,
+  getPendingHandoffs,
+  listHandoffs,
+  loadAgentsManifest,
+  loadTeamState,
+  saveAgentsManifest,
+  saveHandoff,
+  saveTeamState,
+  setCurrentAgent
+} from "./chunk-PMXRGPRQ.js";
+
+// src/commands/team/index.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+import chalk2 from "chalk";
+
+// src/commands/team/configure-models.ts
+import prompts from "prompts";
+import chalk from "chalk";
+
+// src/core/model-discovery.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+var execAsync = promisify(exec);
+var MANIFEST_URL = "https://raw.githubusercontent.com/ascend42/a-paradigm/main/models.json";
+var MANIFEST_CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+var ModelDiscovery = class {
+  cacheFile;
+  manifestCacheFile;
+  cacheTTL = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  constructor(_rootDir) {
+    this.cacheFile = path.join(_rootDir, ".paradigm", "model-cache.json");
+    this.manifestCacheFile = path.join(_rootDir, ".paradigm", "model-manifest-cache.json");
+  }
+  /**
+   * Fetch the remote model manifest (cached for 7 days).
+   * Returns null on any failure — callers fall back to hardcoded presets.
+   */
+  async fetchManifest() {
+    try {
+      if (fs.existsSync(this.manifestCacheFile)) {
+        const raw = fs.readFileSync(this.manifestCacheFile, "utf8");
+        const cached = JSON.parse(raw);
+        const age = Date.now() - new Date(cached._fetchedAt).getTime();
+        if (age < MANIFEST_CACHE_TTL) {
+          return cached;
+        }
+      }
+    } catch {
+    }
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(MANIFEST_URL, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (!response.ok) return null;
+      const manifest = await response.json();
+      try {
+        const dir = path.dirname(this.manifestCacheFile);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(this.manifestCacheFile, JSON.stringify({ ...manifest, _fetchedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+      } catch {
+      }
+      return manifest;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get models for a provider from the remote manifest.
+   * Returns null if manifest unavailable or provider not found.
+   */
+  async getManifestModels(provider) {
+    const manifest = await this.fetchManifest();
+    if (!manifest?.providers?.[provider]) return null;
+    return manifest.providers[provider];
+  }
+  /**
+   * Get environment-specific models from the remote manifest.
+   * Returns null if manifest unavailable or environment not found.
+   */
+  async getManifestEnvironment(env) {
+    const manifest = await this.fetchManifest();
+    if (!manifest?.environments?.[env]) return null;
+    const envConfig = manifest.environments[env];
+    if (envConfig.models) {
+      return envConfig.models;
+    }
+    if (envConfig.include) {
+      const models = [];
+      for (const providerName of envConfig.include) {
+        const providerModels = manifest.providers?.[providerName];
+        if (providerModels) {
+          models.push(...providerModels);
+        }
+      }
+      return models.length > 0 ? models : null;
+    }
+    return null;
+  }
+  /**
+   * Discover available models
+   */
+  async discover() {
+    const cached = this.loadCache();
+    if (cached) return cached;
+    const env = this.detectEnvironment();
+    let result;
+    switch (env) {
+      case "cursor":
+        result = await this.discoverCursorModels();
+        break;
+      case "claude-code":
+        result = this.getClaudeCodeModels();
+        break;
+      case "vscode":
+        result = await this.getVSCodeModels();
+        break;
+      case "multi-provider":
+        result = await this.discoverMultiProviderModels();
+        break;
+      default:
+        result = this.getFallbackModels();
+    }
+    this.saveCache(result);
+    return result;
+  }
+  /**
+   * Detect the current environment
+   */
+  detectEnvironment() {
+    if (process.env.CLAUDE_CODE === "1" || process.env.TERM_PROGRAM === "claude") {
+      return "claude-code";
+    }
+    if (process.env.TERM_PROGRAM === "cursor" || process.env.CURSOR_SESSION || process.env.CURSOR_TRACE_ID || // Cursor sets VSCODE_* vars but with cursor in the path
+    process.env.VSCODE_CWD && process.env.VSCODE_CWD.toLowerCase().includes("cursor") || process.env.VSCODE_NLS_CONFIG && process.env.VSCODE_NLS_CONFIG.toLowerCase().includes("cursor") || // Check if running in Cursor's integrated terminal
+    process.env.TERM_PROGRAM === "vscode" && process.env.VSCODE_GIT_ASKPASS_NODE?.toLowerCase().includes("cursor")) {
+      return "cursor";
+    }
+    if (process.env.TERM_PROGRAM === "vscode" || process.env.VSCODE_PID) {
+      return "vscode";
+    }
+    const providers = this.getAvailableProviders();
+    if (providers.length > 0) {
+      return "multi-provider";
+    }
+    return "fallback";
+  }
+  /**
+   * Get list of providers with configured API keys
+   */
+  getAvailableProviders() {
+    const providers = [];
+    if (process.env.ANTHROPIC_API_KEY) providers.push("anthropic");
+    if (process.env.OPENAI_API_KEY) providers.push("openai");
+    if (process.env.GOOGLE_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY) providers.push("google");
+    if (process.env.XAI_API_KEY) providers.push("xai");
+    if (process.env.MISTRAL_API_KEY) providers.push("mistral");
+    if (process.env.DEEPSEEK_API_KEY) providers.push("deepseek");
+    if (process.env.COHERE_API_KEY) providers.push("cohere");
+    if (process.env.OPENROUTER_API_KEY) providers.push("openrouter");
+    return providers;
+  }
+  /**
+   * Discover models from all available providers
+   */
+  async discoverMultiProviderModels() {
+    const providers = this.getAvailableProviders();
+    const allModels = [];
+    const discoveries = await Promise.allSettled(
+      providers.map((provider) => this.discoverProviderModels(provider))
+    );
+    for (const result of discoveries) {
+      if (result.status === "fulfilled" && result.value) {
+        allModels.push(...result.value.models);
+      }
+    }
+    if (allModels.length === 0) {
+      return this.getFallbackModels();
+    }
+    return {
+      source: "multi-provider",
+      models: allModels,
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Discover models for a specific provider
+   */
+  async discoverProviderModels(provider) {
+    switch (provider) {
+      case "anthropic":
+        return this.discoverAnthropicModels();
+      case "openai":
+        return this.discoverOpenAIModels();
+      case "google":
+        return this.discoverGoogleModels();
+      case "xai":
+        return this.discoverXAIModels();
+      case "openrouter":
+        return this.discoverOpenRouterModels();
+      default:
+        return null;
+    }
+  }
+  /**
+   * Discover Anthropic models via API
+   */
+  async discoverAnthropicModels() {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/models", {
+        headers: {
+          "x-api-key": process.env.ANTHROPIC_API_KEY,
+          "anthropic-version": "2023-06-01"
+        }
+      });
+      if (!response.ok) {
+        return await this.getAnthropicPresets();
+      }
+      const data = await response.json();
+      if (!data.data || data.data.length === 0) {
+        return await this.getAnthropicPresets();
+      }
+      return {
+        source: "anthropic-api",
+        models: data.data.map((m) => ({
+          id: m.id,
+          name: m.display_name || this.formatModelName(m.id),
+          provider: "anthropic",
+          family: this.extractFamily(m.id, "claude")
+        })),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      return await this.getAnthropicPresets();
+    }
+  }
+  /**
+   * Discover OpenAI models via API
+   */
+  async discoverOpenAIModels() {
+    try {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        headers: { "Authorization": `Bearer ${process.env.OPENAI_API_KEY}` }
+      });
+      if (!response.ok) {
+        return await this.getOpenAIPresets();
+      }
+      const data = await response.json();
+      if (!data.data) {
+        return await this.getOpenAIPresets();
+      }
+      const chatModels = data.data.filter(
+        (m) => m.id.includes("gpt-4") || m.id.includes("o1") || m.id.includes("o3") || m.id.includes("o4")
+      );
+      return {
+        source: "openai",
+        models: chatModels.map((m) => ({
+          id: m.id,
+          name: this.formatModelName(m.id),
+          provider: "openai",
+          family: this.extractFamily(m.id, "gpt")
+        })),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      return await this.getOpenAIPresets();
+    }
+  }
+  /**
+   * Discover Google models via API
+   */
+  async discoverGoogleModels() {
+    try {
+      const apiKey = process.env.GOOGLE_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+      );
+      if (!response.ok) {
+        return await this.getGooglePresets();
+      }
+      const data = await response.json();
+      if (!data.models) {
+        return await this.getGooglePresets();
+      }
+      return {
+        source: "google",
+        models: data.models.filter((m) => m.name.includes("gemini")).map((m) => ({
+          id: m.name.replace("models/", ""),
+          name: m.displayName || this.formatModelName(m.name),
+          provider: "google",
+          family: "gemini"
+        })),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      return await this.getGooglePresets();
+    }
+  }
+  /**
+   * Discover xAI/Grok models via API
+   */
+  async discoverXAIModels() {
+    try {
+      const response = await fetch("https://api.x.ai/v1/models", {
+        headers: { "Authorization": `Bearer ${process.env.XAI_API_KEY}` }
+      });
+      if (!response.ok) {
+        return await this.getXAIPresets();
+      }
+      const data = await response.json();
+      if (!data.data) {
+        return await this.getXAIPresets();
+      }
+      return {
+        source: "xai",
+        models: data.data.map((m) => ({
+          id: m.id,
+          name: m.id.includes("grok") ? `Grok ${m.id.split("-").pop()}` : m.id,
+          provider: "xai",
+          family: "grok"
+        })),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      return await this.getXAIPresets();
+    }
+  }
+  /**
+   * Discover OpenRouter models via API
+   */
+  async discoverOpenRouterModels() {
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models", {
+        headers: { "Authorization": `Bearer ${process.env.OPENROUTER_API_KEY}` }
+      });
+      if (!response.ok) {
+        return { source: "openrouter", models: [], cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      const data = await response.json();
+      if (!data.data) {
+        return { source: "openrouter", models: [], cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      return {
+        source: "openrouter",
+        models: data.data.slice(0, 30).map((m) => ({
+          id: m.id,
+          name: m.name || m.id,
+          provider: m.id.split("/")[0] || "openrouter"
+        })),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      return { source: "openrouter", models: [], cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+  }
+  /**
+   * Discover Cursor models
+   */
+  async discoverCursorModels() {
+    try {
+      const { stdout } = await execAsync("cursor agent models --json", { timeout: 5e3 });
+      const models = JSON.parse(stdout);
+      return {
+        source: "cursor",
+        models: models.map((m) => this.normalizeModel(m)),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch {
+      const manifest = await this.getManifestEnvironment("cursor");
+      return {
+        source: manifest ? "cursor-manifest" : "cursor",
+        models: manifest || this.getCursorPresets(),
+        cached: false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  /**
+   * Get Claude Code models (fixed list)
+   */
+  getClaudeCodeModels() {
+    return {
+      source: "claude-code",
+      models: [
+        { id: "opus", name: "Claude Opus", provider: "anthropic", family: "claude" },
+        { id: "sonnet", name: "Claude Sonnet", provider: "anthropic", family: "claude" },
+        { id: "haiku", name: "Claude Haiku", provider: "anthropic", family: "claude" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get VSCode/Copilot models
+   */
+  async getVSCodeModels() {
+    const manifest = await this.getManifestEnvironment("vscode");
+    if (manifest) {
+      return { source: "vscode-manifest", models: manifest, cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return {
+      source: "vscode",
+      models: [
+        { id: "gpt-4.1", name: "GPT-4.1", provider: "openai", family: "gpt-4.1" },
+        { id: "gpt-4.1-mini", name: "GPT-4.1 Mini", provider: "openai", family: "gpt-4.1" },
+        { id: "gpt-4.1-nano", name: "GPT-4.1 Nano", provider: "openai", family: "gpt-4.1" },
+        { id: "o3", name: "OpenAI o3", provider: "openai", family: "o3" },
+        { id: "o4-mini", name: "OpenAI o4 Mini", provider: "openai", family: "o4" },
+        { id: "claude-sonnet-4-5-20250929", name: "Claude Sonnet 4.5", provider: "anthropic", family: "claude-4" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get comprehensive preset models for Cursor
+   */
+  getCursorPresets() {
+    return [
+      // Anthropic Claude models
+      { id: "claude-opus-4-6", name: "Claude Opus 4.6", provider: "anthropic", family: "claude-4" },
+      { id: "claude-sonnet-4-5-20250929", name: "Claude Sonnet 4.5", provider: "anthropic", family: "claude-4" },
+      { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", provider: "anthropic", family: "claude-4" },
+      // OpenAI GPT models
+      { id: "gpt-4.1", name: "GPT-4.1", provider: "openai", family: "gpt-4.1" },
+      { id: "gpt-4.1-mini", name: "GPT-4.1 Mini", provider: "openai", family: "gpt-4.1" },
+      { id: "gpt-4.1-nano", name: "GPT-4.1 Nano", provider: "openai", family: "gpt-4.1" },
+      { id: "o3", name: "OpenAI o3", provider: "openai", family: "o3" },
+      { id: "o4-mini", name: "OpenAI o4 Mini", provider: "openai", family: "o4" },
+      { id: "o3-mini", name: "OpenAI o3 Mini", provider: "openai", family: "o3" },
+      // Google Gemini models
+      { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", provider: "google", family: "gemini-2.5" },
+      { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", provider: "google", family: "gemini-2.5" },
+      { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash", provider: "google", family: "gemini-2" },
+      // xAI Grok models
+      { id: "grok-3", name: "Grok 3", provider: "xai", family: "grok" },
+      { id: "grok-3-mini", name: "Grok 3 Mini", provider: "xai", family: "grok" },
+      // Meta Llama models
+      { id: "llama-4-scout", name: "Llama 4 Scout", provider: "meta", family: "llama-4" },
+      { id: "llama-4-maverick", name: "Llama 4 Maverick", provider: "meta", family: "llama-4" },
+      // Mistral models
+      { id: "mistral-large", name: "Mistral Large", provider: "mistral", family: "mistral" },
+      { id: "codestral", name: "Codestral", provider: "mistral", family: "codestral" },
+      // DeepSeek models
+      { id: "deepseek-r1", name: "DeepSeek R1", provider: "deepseek", family: "deepseek" },
+      { id: "deepseek-v3", name: "DeepSeek V3", provider: "deepseek", family: "deepseek" },
+      // Cohere models
+      { id: "command-r-plus", name: "Command R+", provider: "cohere", family: "command" },
+      { id: "command-r", name: "Command R", provider: "cohere", family: "command" }
+    ];
+  }
+  /**
+   * Get Anthropic preset models (manifest → hardcoded)
+   */
+  async getAnthropicPresets() {
+    const manifest = await this.getManifestModels("anthropic");
+    if (manifest) {
+      return { source: "anthropic-manifest", models: manifest, cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return {
+      source: "anthropic-api",
+      models: [
+        { id: "claude-opus-4-6", name: "Claude Opus 4.6", provider: "anthropic", family: "claude-4" },
+        { id: "claude-sonnet-4-5-20250929", name: "Claude Sonnet 4.5", provider: "anthropic", family: "claude-4" },
+        { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", provider: "anthropic", family: "claude-4" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get OpenAI preset models (manifest → hardcoded)
+   */
+  async getOpenAIPresets() {
+    const manifest = await this.getManifestModels("openai");
+    if (manifest) {
+      return { source: "openai-manifest", models: manifest, cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return {
+      source: "openai",
+      models: [
+        { id: "gpt-4.1", name: "GPT-4.1", provider: "openai", family: "gpt-4.1" },
+        { id: "gpt-4.1-mini", name: "GPT-4.1 Mini", provider: "openai", family: "gpt-4.1" },
+        { id: "gpt-4.1-nano", name: "GPT-4.1 Nano", provider: "openai", family: "gpt-4.1" },
+        { id: "o3", name: "OpenAI o3", provider: "openai", family: "o3" },
+        { id: "o4-mini", name: "OpenAI o4 Mini", provider: "openai", family: "o4" },
+        { id: "o3-mini", name: "OpenAI o3 Mini", provider: "openai", family: "o3" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get Google preset models (manifest → hardcoded)
+   */
+  async getGooglePresets() {
+    const manifest = await this.getManifestModels("google");
+    if (manifest) {
+      return { source: "google-manifest", models: manifest, cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return {
+      source: "google",
+      models: [
+        { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", provider: "google", family: "gemini-2.5" },
+        { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", provider: "google", family: "gemini-2.5" },
+        { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash", provider: "google", family: "gemini-2" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get xAI preset models (manifest → hardcoded)
+   */
+  async getXAIPresets() {
+    const manifest = await this.getManifestModels("xai");
+    if (manifest) {
+      return { source: "xai-manifest", models: manifest, cached: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return {
+      source: "xai",
+      models: [
+        { id: "grok-3", name: "Grok 3", provider: "xai", family: "grok" },
+        { id: "grok-3-mini", name: "Grok 3 Mini", provider: "xai", family: "grok" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get fallback models (basic Claude models)
+   */
+  getFallbackModels() {
+    return {
+      source: "fallback",
+      models: [
+        { id: "opus", name: "Claude Opus", provider: "anthropic", family: "claude" },
+        { id: "sonnet", name: "Claude Sonnet", provider: "anthropic", family: "claude" },
+        { id: "haiku", name: "Claude Haiku", provider: "anthropic", family: "claude" }
+      ],
+      cached: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Normalize a model from external source
+   */
+  normalizeModel(model) {
+    return {
+      id: model.id,
+      name: model.name || this.formatModelName(model.id),
+      provider: model.provider || "unknown",
+      family: model.family,
+      capabilities: model.capabilities
+    };
+  }
+  /**
+   * Format a model ID into a human-readable name
+   */
+  formatModelName(id) {
+    return id.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).replace(/(\d)([a-z])/gi, "$1 $2");
+  }
+  /**
+   * Extract model family from ID
+   */
+  extractFamily(id, defaultFamily) {
+    const patterns = [
+      [/claude-4|claude-opus-4|claude-sonnet-4|claude-haiku-4/i, "claude-4"],
+      [/claude-3\.5|claude-3-5/i, "claude-3.5"],
+      [/claude-3/i, "claude-3"],
+      [/gpt-4\.1/i, "gpt-4.1"],
+      [/gpt-4o/i, "gpt-4o"],
+      [/gpt-4/i, "gpt-4"],
+      [/o4/i, "o4"],
+      [/o3/i, "o3"],
+      [/o1/i, "o1"],
+      [/gemini-2\.5/i, "gemini-2.5"],
+      [/gemini-2/i, "gemini-2"],
+      [/gemini-1\.5/i, "gemini-1.5"],
+      [/grok/i, "grok"],
+      [/llama-4/i, "llama-4"],
+      [/llama/i, "llama"],
+      [/mistral/i, "mistral"]
+    ];
+    for (const [pattern, family] of patterns) {
+      if (pattern.test(id)) {
+        return family;
+      }
+    }
+    return defaultFamily;
+  }
+  /**
+   * Load cached models
+   */
+  loadCache() {
+    try {
+      if (!fs.existsSync(this.cacheFile)) {
+        return null;
+      }
+      const content = fs.readFileSync(this.cacheFile, "utf8");
+      const cached = JSON.parse(content);
+      const cacheTime = new Date(cached.timestamp).getTime();
+      if (Date.now() - cacheTime > this.cacheTTL) {
+        return null;
+      }
+      return { ...cached, cached: true };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save models to cache
+   */
+  saveCache(result) {
+    try {
+      const dir = path.dirname(this.cacheFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.cacheFile, JSON.stringify(result, null, 2));
+    } catch {
+    }
+  }
+  /**
+   * Clear the cache
+   */
+  clearCache() {
+    try {
+      if (fs.existsSync(this.cacheFile)) {
+        fs.unlinkSync(this.cacheFile);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get models grouped by tier (high/medium/low)
+   */
+  groupByTier(models) {
+    const high = [];
+    const medium = [];
+    const low = [];
+    const miniPattern = /\bmini\b/i;
+    const flashPattern = /\bflash\b/i;
+    const smallPattern = /\bsmall\b/i;
+    for (const model of models) {
+      const name = model.name.toLowerCase();
+      const id = model.id.toLowerCase();
+      const combined = `${name} ${id}`;
+      const isLowTier = name.includes("haiku") || miniPattern.test(combined) || name.includes("nano") || flashPattern.test(combined) && !name.includes("flash-thinking") || smallPattern.test(combined) || name.includes("scout") || name.includes("instant");
+      const isHighTier = name.includes("opus") || name.includes("gpt-4") && !miniPattern.test(combined) && !name.includes("nano") || id.includes("gpt-4.1") && !miniPattern.test(combined) && !id.includes("nano") || (id === "o3" || id.includes("o3") && !miniPattern.test(combined)) || (id === "o1" || id.includes("o1") && !miniPattern.test(combined) && !id.includes("o1-")) || // Pro models (Gemini Pro, etc.) but not mini variants
+      id.includes("-pro") && !miniPattern.test(combined) || id.includes("grok-3") && !miniPattern.test(combined) || id.includes("grok-2") && !miniPattern.test(combined) || name.includes("large") || name.includes("maverick") || name.includes("command r+") || id.includes("deepseek-r1") || id.includes("deepseek-v3");
+      if (isLowTier) {
+        low.push(model);
+      } else if (isHighTier) {
+        high.push(model);
+      } else {
+        medium.push(model);
+      }
+    }
+    return { high, medium, low };
+  }
+};
+
+// src/commands/team/configure-models.ts
+import * as path2 from "path";
+function shouldPromptForModels() {
+  if (process.env.CLAUDE_CODE === "1" || process.env.TERM_PROGRAM === "claude") {
+    return false;
+  }
+  if (process.env.TERM_PROGRAM === "cursor" || process.env.CURSOR_SESSION || process.env.CURSOR_TRACE_ID || process.env.VSCODE_CWD && process.env.VSCODE_CWD.toLowerCase().includes("cursor") || process.env.VSCODE_NLS_CONFIG && process.env.VSCODE_NLS_CONFIG.toLowerCase().includes("cursor") || process.env.TERM_PROGRAM === "vscode" && process.env.VSCODE_GIT_ASKPASS_NODE?.toLowerCase().includes("cursor")) {
+    return true;
+  }
+  if (process.stdin.isTTY) {
+    return true;
+  }
+  return false;
+}
+async function promptForAgentModels(rootDir) {
+  const discovery = new ModelDiscovery(rootDir);
+  const result = await discovery.discover();
+  console.log(chalk.cyan("\n  Configure Agent Models\n"));
+  console.log(chalk.gray(`    Environment: ${result.source}`));
+  console.log(chalk.gray(`    Available: ${result.models.length} models
+`));
+  const models = {};
+  const tiers = discovery.groupByTier(result.models);
+  const buildChoices = (agent) => {
+    const rec = AGENT_MODEL_RECOMMENDATIONS[agent];
+    const recommended = rec.tier === "high" ? tiers.high : rec.tier === "medium" ? tiers.medium : tiers.low;
+    const choices = [];
+    for (const model of recommended) {
+      const isFirst = choices.length === 0;
+      choices.push({
+        title: isFirst ? `${model.name} (recommended)` : model.name,
+        value: model.id,
+        description: `${model.provider} - ${rec.tier} tier`
+      });
+    }
+    const otherHigh = tiers.high.filter((m) => !recommended.includes(m));
+    const otherMedium = tiers.medium.filter((m) => !recommended.includes(m));
+    const otherLow = tiers.low.filter((m) => !recommended.includes(m));
+    for (const model of otherHigh) {
+      choices.push({
+        title: model.name,
+        value: model.id,
+        description: `${model.provider} - high tier`
+      });
+    }
+    for (const model of otherMedium) {
+      choices.push({
+        title: model.name,
+        value: model.id,
+        description: `${model.provider} - medium tier`
+      });
+    }
+    for (const model of otherLow) {
+      choices.push({
+        title: model.name,
+        value: model.id,
+        description: `${model.provider} - low tier`
+      });
+    }
+    return choices;
+  };
+  for (const agent of ["architect", "builder", "tester", "reviewer", "security"]) {
+    const rec = AGENT_MODEL_RECOMMENDATIONS[agent];
+    const label = agent.charAt(0).toUpperCase() + agent.slice(1);
+    const choices = buildChoices(agent);
+    const response = await prompts({
+      type: "select",
+      name: "model",
+      message: `${label} (${rec.description})`,
+      choices,
+      initial: 0
+    }, {
+      onCancel: () => {
+        console.log(chalk.yellow("\n  Cancelled. Using defaults.\n"));
+        process.exit(0);
+      }
+    });
+    models[agent] = { id: response.model };
+    console.log(chalk.green(`    \u2713 ${label}: ${response.model}
+`));
+  }
+  return models;
+}
+async function teamModelsCommand(targetPath, options) {
+  const rootDir = targetPath ? path2.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  const discovery = new ModelDiscovery(rootDir);
+  if (options.refresh) {
+    discovery.clearCache();
+  }
+  const available = await discovery.discover();
+  if (options.json) {
+    const agentModels = {};
+    if (manifest?.agents) {
+      for (const [name, agent] of Object.entries(manifest.agents)) {
+        agentModels[name] = agent.defaultModel || "default";
+      }
+    }
+    console.log(JSON.stringify({
+      environment: available.source,
+      cached: available.cached,
+      agents: agentModels,
+      available: available.models
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.cyan("\n  Agent Model Configuration\n"));
+  console.log(chalk.gray(`    Environment: ${available.source}${available.cached ? " (cached)" : ""}`));
+  console.log(chalk.gray(`    Available models: ${available.models.length}
+`));
+  console.log("    Current assignments:");
+  console.log(chalk.gray("    \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.gray("    \u2502 Agent       \u2502 Model                 \u2502"));
+  console.log(chalk.gray("    \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+  if (manifest?.agents) {
+    for (const [name, agent] of Object.entries(manifest.agents)) {
+      const model = agent.defaultModel || "default";
+      const paddedName = name.padEnd(11);
+      const paddedModel = model.padEnd(21);
+      console.log(chalk.gray("    \u2502 ") + chalk.white(paddedName) + chalk.gray(" \u2502 ") + chalk.yellow(paddedModel) + chalk.gray(" \u2502"));
+    }
+  } else {
+    console.log(chalk.gray("    \u2502 (no agents configured)             \u2502"));
+  }
+  console.log(chalk.gray("    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n"));
+  const tiers = discovery.groupByTier(available.models);
+  console.log(chalk.cyan("    Available models by tier:\n"));
+  if (tiers.high.length > 0) {
+    console.log(chalk.yellow("    High (complex reasoning):"));
+    for (const m of tiers.high.slice(0, 5)) {
+      console.log(chalk.gray(`      - ${m.name} (${m.provider})`));
+    }
+    if (tiers.high.length > 5) {
+      console.log(chalk.gray(`      ... and ${tiers.high.length - 5} more`));
+    }
+    console.log();
+  }
+  if (tiers.medium.length > 0) {
+    console.log(chalk.blue("    Medium (balanced):"));
+    for (const m of tiers.medium.slice(0, 5)) {
+      console.log(chalk.gray(`      - ${m.name} (${m.provider})`));
+    }
+    if (tiers.medium.length > 5) {
+      console.log(chalk.gray(`      ... and ${tiers.medium.length - 5} more`));
+    }
+    console.log();
+  }
+  if (tiers.low.length > 0) {
+    console.log(chalk.green("    Low (fast & cheap):"));
+    for (const m of tiers.low.slice(0, 5)) {
+      console.log(chalk.gray(`      - ${m.name} (${m.provider})`));
+    }
+    if (tiers.low.length > 5) {
+      console.log(chalk.gray(`      ... and ${tiers.low.length - 5} more`));
+    }
+    console.log();
+  }
+  if (process.stdin.isTTY && !options.json) {
+    console.log(chalk.gray("    \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"));
+    const { action } = await prompts({
+      type: "select",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { title: "Reconfigure all models", value: "all" },
+        { title: "Exit", value: "exit" }
+      ],
+      initial: 1
+    });
+    if (action === "all" && manifest) {
+      const models = await promptForAgentModels(rootDir);
+      for (const [agentName, config] of Object.entries(models)) {
+        if (manifest.agents[agentName]) {
+          manifest.agents[agentName].defaultModel = mapToSimpleModel(config.id);
+        }
+      }
+      saveAgentsManifest(rootDir, manifest);
+      console.log(chalk.green("\n    \u2713 Model configuration updated.\n"));
+    }
+  }
+}
+function mapToSimpleModel(modelId) {
+  const id = modelId.toLowerCase();
+  if (id.includes("opus") || id.includes("gpt-4") && !id.includes("mini") && !id.includes("nano") || (id === "o3" || id.includes("o3") && !id.includes("mini")) || id.includes("o1") && !id.includes("mini") || id.includes("-pro") && !id.includes("mini") || id.includes("large") || id.includes("maverick") || id.includes("deepseek-r1") || id.includes("grok-3") && !id.includes("mini") || id.includes("grok-2") && !id.includes("mini")) {
+    return "opus";
+  }
+  if (id.includes("haiku") || id.includes("mini") || id.includes("nano") || id.includes("flash") || id.includes("scout") || id.includes("small")) {
+    return "haiku";
+  }
+  return "sonnet";
+}
+
+// src/commands/team/index.ts
+async function teamInitCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const projectName = path3.basename(rootDir);
+  const agentsPath = getAgentsPath(rootDir);
+  if (!options.json) {
+    console.log(chalk2.blue("\n  Initialize Paradigm Team\n"));
+  }
+  if (agentsConfigured(rootDir) && !options.force) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team already configured", path: agentsPath }));
+    } else {
+      console.log(chalk2.yellow(`  Team already configured at ${agentsPath}`));
+      console.log(chalk2.gray("  Use --force to reinitialize.\n"));
+    }
+    return;
+  }
+  let modelOverrides;
+  const shouldConfigure = options.configureModels || shouldPromptForModels() && options.noConfigureModels !== true;
+  if (shouldConfigure && !options.json) {
+    try {
+      modelOverrides = await promptForAgentModels(rootDir);
+    } catch {
+    }
+  }
+  const manifest = generateDefaultManifest(projectName, modelOverrides);
+  saveAgentsManifest(rootDir, manifest);
+  const state = {
+    current: null,
+    queue: [],
+    recent: [],
+    blocked: []
+  };
+  saveTeamState(rootDir, state);
+  if (options.json) {
+    const agentModels = {};
+    for (const [name, agent] of Object.entries(manifest.agents)) {
+      agentModels[name] = agent.defaultModel || "default";
+    }
+    console.log(JSON.stringify({
+      success: true,
+      path: agentsPath,
+      agents: Object.keys(manifest.agents),
+      models: agentModels
+    }));
+    return;
+  }
+  console.log(chalk2.green("  \u2713 Team configuration created\n"));
+  console.log(chalk2.gray(`    ${agentsPath}
+`));
+  console.log(chalk2.cyan("  Available agents:"));
+  for (const [name, agent] of Object.entries(manifest.agents)) {
+    const model = agent.defaultModel || "default";
+    console.log(`    ${chalk2.yellow(name.padEnd(12))} ${chalk2.gray(`(${model})`)} ${agent.role.split("\n")[0]}`);
+  }
+  console.log(chalk2.cyan("\n  Next steps:"));
+  console.log(chalk2.gray("    1. Review .paradigm/agents.yaml and customize roles"));
+  console.log(chalk2.gray("    2. Run `paradigm team models` to reconfigure models"));
+  console.log(chalk2.gray("    3. Run `paradigm team status` to see team state"));
+  console.log(chalk2.gray("    4. Use `paradigm team handoff --to <agent>` to hand off work\n"));
+}
+async function teamStatusCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  if (options.id) {
+    return showOrchestrationStatus(rootDir, options.id, options);
+  }
+  if (options.running) {
+    return showRunningOrchestrations(rootDir, options);
+  }
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const state = loadTeamState(rootDir);
+  const pending = getPendingHandoffs(rootDir);
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const running = bgOrchestrator.getRunning();
+  if (options.json) {
+    console.log(JSON.stringify({
+      team: manifest.team,
+      agents: Object.keys(manifest.agents),
+      current: state.current,
+      queue: state.queue,
+      pending_handoffs: pending.length,
+      running_orchestrations: running.length,
+      recent: state.recent.slice(0, 5)
+    }, null, 2));
+    return;
+  }
+  console.log(chalk2.blue("\n\u{1F465} Paradigm Team Status\n"));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(chalk2.white(`Team: ${manifest.team.name}`));
+  console.log(chalk2.gray(`Agents: ${Object.keys(manifest.agents).join(", ")}`));
+  console.log();
+  if (running.length > 0) {
+    console.log(chalk2.cyan("Running Orchestrations:"));
+    for (const orch of running) {
+      const elapsed = orch.started ? Math.floor((Date.now() - new Date(orch.started).getTime()) / 6e4) : 0;
+      console.log(`  ${chalk2.yellow("\u25B6")} ${orch.id}`);
+      console.log(chalk2.gray(`    ${orch.task.slice(0, 40)}${orch.task.length > 40 ? "..." : ""}`));
+      console.log(chalk2.gray(`    Running for ${elapsed}m | Mode: ${orch.mode}`));
+    }
+    console.log(chalk2.gray(`
+  Use --running to see details, or \`tail -f <output_file>\` for logs`));
+    console.log();
+  }
+  if (state.current) {
+    const elapsed = Date.now() - new Date(state.current.started).getTime();
+    const mins = Math.floor(elapsed / 6e4);
+    console.log(chalk2.cyan("Current Agent:"));
+    console.log(`  ${chalk2.yellow(state.current.agent.toUpperCase())} - ${state.current.task}`);
+    console.log(chalk2.gray(`  Started ${mins}m ago`));
+    if (state.current.symbols_touched.length > 0) {
+      console.log(chalk2.gray(`  Touched: ${state.current.symbols_touched.join(", ")}`));
+    }
+    console.log();
+  } else {
+    console.log(chalk2.cyan("Current Agent:"));
+    console.log(chalk2.gray("  No active agent"));
+    console.log();
+  }
+  if (pending.length > 0) {
+    console.log(chalk2.cyan("Pending Handoffs:"));
+    for (const h of pending) {
+      console.log(`  ${chalk2.yellow(h.from)} \u2192 ${chalk2.green(h.to)}: ${h.context.summary.substring(0, 50)}...`);
+    }
+    console.log(chalk2.gray(`
+  Run \`paradigm team accept\` to accept a handoff`));
+    console.log();
+  }
+  if (state.queue.length > 0) {
+    console.log(chalk2.cyan("Queue:"));
+    for (const q of state.queue) {
+      console.log(`  ${chalk2.yellow(q.agent)} waiting for ${q.waiting_for}: ${q.task}`);
+    }
+    console.log();
+  }
+  if (state.blocked.length > 0) {
+    console.log(chalk2.red("Blocked:"));
+    for (const b of state.blocked) {
+      console.log(`  ${chalk2.yellow(b.agent)}: ${b.reason}`);
+    }
+    console.log();
+  }
+  if (state.recent.length > 0) {
+    console.log(chalk2.cyan("Recent Activity:"));
+    for (const a of state.recent.slice(0, 5)) {
+      const time = new Date(a.timestamp).toLocaleTimeString();
+      const status = a.result === "success" ? chalk2.green("\u2713") : a.result === "failed" ? chalk2.red("\u2717") : a.result === "blocked" ? chalk2.yellow("\u2298") : chalk2.gray("\u25CB");
+      const handoff = a.handed_to ? ` \u2192 ${a.handed_to}` : "";
+      console.log(`  ${status} ${time} ${chalk2.gray(a.agent)}: ${a.task}${handoff}`);
+    }
+    console.log();
+  }
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(chalk2.gray("Commands: team status | team status --running | team diff <id> | team accept <id>"));
+  console.log();
+}
+async function showRunningOrchestrations(rootDir, options) {
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const running = bgOrchestrator.listOrchestrations({ status: ["running", "pending"] });
+  const completed = bgOrchestrator.listOrchestrations({ status: "completed", limit: 5 });
+  if (options.json) {
+    console.log(JSON.stringify({
+      running,
+      recently_completed: completed
+    }, null, 2));
+    return;
+  }
+  console.log(chalk2.blue("\n\u{1F504} Running Orchestrations\n"));
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  if (running.length === 0) {
+    console.log(chalk2.gray("  No orchestrations currently running."));
+    console.log();
+  } else {
+    for (const orch of running) {
+      const elapsed = orch.started ? Math.floor((Date.now() - new Date(orch.started).getTime()) / 6e4) : 0;
+      const statusIcon = orch.status === "running" ? chalk2.yellow("\u25B6") : chalk2.gray("\u25CB");
+      console.log(`  ${statusIcon} ${chalk2.cyan(orch.id)}`);
+      console.log(chalk2.white(`    Task: ${orch.task.slice(0, 50)}${orch.task.length > 50 ? "..." : ""}`));
+      console.log(chalk2.gray(`    Status: ${orch.status} | Mode: ${orch.mode} | Duration: ${elapsed}m`));
+      console.log(chalk2.gray(`    Output: ${orch.outputFile}`));
+      console.log();
+    }
+  }
+  if (completed.length > 0) {
+    console.log(chalk2.cyan("Recently Completed:"));
+    for (const orch of completed) {
+      const statusIcon = orch.status === "completed" ? chalk2.green("\u2713") : orch.status === "failed" ? chalk2.red("\u2717") : orch.status === "accepted" ? chalk2.green("\u2713\u2713") : chalk2.gray("\u25CB");
+      console.log(`  ${statusIcon} ${orch.id} - ${orch.task.slice(0, 40)}${orch.task.length > 40 ? "..." : ""}`);
+    }
+    console.log();
+  }
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  console.log(chalk2.gray("Commands: team status <id> | team diff <id> | team accept <id>"));
+  console.log();
+}
+async function showOrchestrationStatus(rootDir, id, options) {
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const orch = bgOrchestrator.getOrchestration(id);
+  if (!orch) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration not found", id }));
+    } else {
+      console.log(chalk2.red(`
+Orchestration not found: ${id}
+`));
+    }
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(orch, null, 2));
+    return;
+  }
+  const statusIcon = orch.status === "running" ? chalk2.yellow("\u25B6") : orch.status === "completed" ? chalk2.green("\u2713") : orch.status === "failed" ? chalk2.red("\u2717") : orch.status === "accepted" ? chalk2.green("\u2713\u2713") : orch.status === "rejected" ? chalk2.red("\u2717\u2717") : chalk2.gray("\u25CB");
+  console.log();
+  console.log(chalk2.blue("\u2501".repeat(60)));
+  console.log(chalk2.blue(`  Orchestration: ${orch.id}`));
+  console.log(chalk2.blue("\u2501".repeat(60)));
+  console.log();
+  console.log(`  Status: ${statusIcon} ${orch.status}`);
+  console.log(chalk2.gray(`  Task: ${orch.task}`));
+  console.log(chalk2.gray(`  Mode: ${orch.mode}`));
+  console.log(chalk2.gray(`  Created: ${orch.created}`));
+  if (orch.started) {
+    console.log(chalk2.gray(`  Started: ${orch.started}`));
+  }
+  if (orch.completed) {
+    console.log(chalk2.gray(`  Completed: ${orch.completed}`));
+  }
+  console.log();
+  if (orch.parallelBuilderStats) {
+    console.log(chalk2.cyan("  Parallel Builders:"));
+    console.log(chalk2.gray(`    Used file plan: ${orch.parallelBuilderStats.usedFilePlan ? "Yes" : "No"}`));
+    console.log(chalk2.gray(`    Sub-phases: ${orch.parallelBuilderStats.totalSubPhases}`));
+    console.log(chalk2.gray(`    Parallel builders: ${orch.parallelBuilderStats.totalParallelBuilders}`));
+    console.log(chalk2.gray(`    Files created: ${orch.parallelBuilderStats.filesCreated}`));
+    console.log();
+  }
+  if (orch.artifacts.length > 0) {
+    console.log(chalk2.cyan("  Artifacts:"));
+    for (const artifact of orch.artifacts) {
+      const icon = artifact.action === "created" ? chalk2.green("+") : artifact.action === "modified" ? chalk2.yellow("~") : chalk2.red("-");
+      console.log(`    ${icon} ${artifact.path}`);
+    }
+    console.log();
+  }
+  if (orch.result) {
+    console.log(chalk2.cyan("  Result:"));
+    console.log(chalk2.gray(`    Agents spawned: ${orch.result.agentsSpawned}`));
+    console.log(chalk2.gray(`    Total tokens: ${orch.result.totalTokens.total}`));
+    console.log(chalk2.gray(`    Total cost: $${orch.result.totalCost.toFixed(4)}`));
+    console.log(chalk2.gray(`    Duration: ${(orch.result.duration_ms / 1e3).toFixed(1)}s`));
+    console.log();
+  }
+  if (orch.error) {
+    console.log(chalk2.red(`  Error: ${orch.error}`));
+    console.log();
+  }
+  console.log(chalk2.gray(`  Output file: ${orch.outputFile}`));
+  console.log();
+  if (orch.status === "completed") {
+    console.log(chalk2.cyan("  Actions:"));
+    console.log(chalk2.gray(`    paradigm team diff ${orch.id}    # View changes`));
+    console.log(chalk2.gray(`    paradigm team accept ${orch.id}  # Accept changes`));
+    console.log(chalk2.gray(`    paradigm team reject ${orch.id}  # Reject changes`));
+    console.log();
+  }
+}
+async function teamHandoffCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const state = loadTeamState(rootDir);
+  if (!manifest.agents[options.to]) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Unknown agent",
+        agent: options.to,
+        available: Object.keys(manifest.agents)
+      }));
+    } else {
+      console.log(chalk2.red(`
+Unknown agent: ${options.to}`));
+      console.log(chalk2.gray(`Available agents: ${Object.keys(manifest.agents).join(", ")}
+`));
+    }
+    return;
+  }
+  const fromAgent = state.current?.agent || manifest.team.default_agent;
+  const handoffId = `${Date.now()}-${fromAgent}-${options.to}`;
+  const handoff = {
+    id: handoffId,
+    from: fromAgent,
+    to: options.to,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "pending",
+    completed: {
+      symbols: state.current?.symbols_touched || [],
+      artifacts: []
+    },
+    context: {
+      summary: options.summary || `Task handed off from ${fromAgent} to ${options.to}`,
+      key_symbols: [],
+      warnings: []
+    }
+  };
+  saveHandoff(rootDir, handoff);
+  addActivity(rootDir, {
+    agent: fromAgent,
+    task: state.current?.task || "Unknown task",
+    result: "success",
+    handed_to: options.to
+  });
+  clearCurrentAgent(rootDir);
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      handoff_id: handoffId,
+      from: fromAgent,
+      to: options.to
+    }));
+    return;
+  }
+  console.log(chalk2.blue("\n\u270B Handoff Created\n"));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(`  From: ${chalk2.yellow(fromAgent)}`);
+  console.log(`  To:   ${chalk2.green(options.to)}`);
+  console.log(`  ID:   ${chalk2.gray(handoffId)}`);
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  const targetAgent = manifest.agents[options.to];
+  console.log(chalk2.cyan("\nTarget agent role:"));
+  for (const line of targetAgent.role.split("\n")) {
+    console.log(chalk2.gray(`  ${line}`));
+  }
+  console.log(chalk2.cyan("\nNext steps:"));
+  console.log(chalk2.gray(`  1. The ${options.to} agent will see this handoff`));
+  console.log(chalk2.gray(`  2. Run \`paradigm team accept\` as ${options.to} to accept`));
+  console.log();
+}
+async function teamAcceptCommand(handoffId, targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const pending = getPendingHandoffs(rootDir);
+  if (pending.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "No pending handoffs" }));
+    } else {
+      console.log(chalk2.yellow("\nNo pending handoffs to accept.\n"));
+    }
+    return;
+  }
+  let handoff;
+  if (handoffId) {
+    handoff = pending.find((h) => h.id === handoffId);
+    if (!handoff) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: "Handoff not found", id: handoffId }));
+      } else {
+        console.log(chalk2.red(`
+Handoff not found: ${handoffId}
+`));
+      }
+      return;
+    }
+  } else {
+    handoff = pending[0];
+  }
+  handoff.status = "accepted";
+  handoff.accepted_at = (/* @__PURE__ */ new Date()).toISOString();
+  handoff.acceptance_note = options.note;
+  saveHandoff(rootDir, handoff);
+  setCurrentAgent(rootDir, handoff.to, `Accepted from ${handoff.from}: ${handoff.context.summary}`);
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      handoff_id: handoff.id,
+      agent: handoff.to,
+      from: handoff.from,
+      context: handoff.context
+    }));
+    return;
+  }
+  console.log(chalk2.blue("\n\u2713 Handoff Accepted\n"));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(`  You are now: ${chalk2.green(handoff.to.toUpperCase())}`);
+  console.log(`  From:        ${chalk2.yellow(handoff.from)}`);
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  console.log(chalk2.cyan("\nContext from previous agent:"));
+  console.log(chalk2.white(`  ${handoff.context.summary}`));
+  if (handoff.completed.symbols.length > 0) {
+    console.log(chalk2.cyan("\nSymbols touched:"));
+    for (const sym of handoff.completed.symbols) {
+      console.log(chalk2.gray(`  \u2022 ${sym}`));
+    }
+  }
+  if (handoff.context.warnings.length > 0) {
+    console.log(chalk2.yellow("\nWarnings:"));
+    for (const warn of handoff.context.warnings) {
+      console.log(chalk2.yellow(`  \u26A0 ${warn}`));
+    }
+  }
+  const agent = manifest.agents[handoff.to];
+  console.log(chalk2.cyan("\nYour role:"));
+  for (const line of agent.role.split("\n")) {
+    console.log(chalk2.gray(`  ${line}`));
+  }
+  console.log();
+}
+async function teamCheckCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const state = loadTeamState(rootDir);
+  const pending = getPendingHandoffs(rootDir);
+  const issues = [];
+  for (const h of pending) {
+    const age = Date.now() - new Date(h.timestamp).getTime();
+    const hours = Math.floor(age / 36e5);
+    if (hours > 24) {
+      issues.push({
+        type: "stale_handoff",
+        message: `Handoff from ${h.from} to ${h.to} pending for ${hours}h`,
+        severity: "warning"
+      });
+    }
+  }
+  for (const b of state.blocked) {
+    issues.push({
+      type: "blocked_agent",
+      message: `${b.agent} blocked: ${b.reason}`,
+      severity: "error"
+    });
+  }
+  if (state.current) {
+    const elapsed = Date.now() - new Date(state.current.started).getTime();
+    const hours = Math.floor(elapsed / 36e5);
+    if (hours > 8) {
+      issues.push({
+        type: "long_task",
+        message: `Current task running for ${hours}h - consider handing off`,
+        severity: "warning"
+      });
+    }
+  }
+  for (const [name, agent] of Object.entries(manifest.agents)) {
+    for (const target of agent.handoff_to) {
+      if (!manifest.agents[target]) {
+        issues.push({
+          type: "invalid_handoff",
+          message: `${name} can handoff to unknown agent: ${target}`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      issues,
+      current: state.current,
+      pending_count: pending.length
+    }, null, 2));
+    return;
+  }
+  console.log(chalk2.blue("\n\u{1F50D} Team Health Check\n"));
+  console.log(chalk2.gray("\u2500".repeat(50)));
+  if (issues.length === 0) {
+    console.log(chalk2.green("\u2713 No issues found\n"));
+  } else {
+    console.log(chalk2.yellow(`Found ${issues.length} issue(s):
+`));
+    for (const issue of issues) {
+      const icon = issue.severity === "error" ? chalk2.red("\u2717") : chalk2.yellow("\u26A0");
+      console.log(`  ${icon} ${issue.message}`);
+    }
+    console.log();
+  }
+  console.log(chalk2.cyan("Status:"));
+  console.log(`  Current agent: ${state.current ? chalk2.green(state.current.agent) : chalk2.gray("none")}`);
+  console.log(`  Pending handoffs: ${pending.length}`);
+  console.log(`  Blocked agents: ${state.blocked.length}`);
+  console.log();
+}
+async function teamHistoryCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const state = loadTeamState(rootDir);
+  const handoffs = listHandoffs(rootDir);
+  const limit = options.limit || 50;
+  const timeline = [];
+  for (const activity of state.recent) {
+    timeline.push({
+      timestamp: activity.timestamp,
+      type: "activity",
+      agent: activity.agent,
+      description: activity.task,
+      details: {
+        result: activity.result,
+        handed_to: activity.handed_to,
+        artifacts: activity.artifacts
+      }
+    });
+  }
+  for (const handoff of handoffs) {
+    timeline.push({
+      timestamp: handoff.timestamp,
+      type: "handoff",
+      agent: handoff.from,
+      description: `Handoff to ${handoff.to}: ${handoff.context.summary}`,
+      details: {
+        to: handoff.to,
+        status: handoff.status,
+        symbols: handoff.completed.symbols
+      }
+    });
+  }
+  timeline.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  const limited = timeline.slice(0, limit);
+  if (options.json) {
+    console.log(JSON.stringify({
+      total: timeline.length,
+      showing: limited.length,
+      timeline: limited
+    }, null, 2));
+    return;
+  }
+  console.log(chalk2.blue("\n\u{1F4DC} Team History\n"));
+  console.log(chalk2.gray("\u2500".repeat(60)));
+  if (limited.length === 0) {
+    console.log(chalk2.gray("No activity recorded yet.\n"));
+    return;
+  }
+  for (const entry of limited) {
+    const time = new Date(entry.timestamp).toLocaleString();
+    const icon = entry.type === "handoff" ? "\u270B" : entry.details?.result === "success" ? "\u2713" : entry.details?.result === "failed" ? "\u2717" : "\u25CB";
+    const color = entry.type === "handoff" ? chalk2.cyan : entry.details?.result === "success" ? chalk2.green : entry.details?.result === "failed" ? chalk2.red : chalk2.gray;
+    console.log(`${color(icon)} ${chalk2.gray(time)}`);
+    console.log(`  ${chalk2.yellow(entry.agent)}: ${entry.description}`);
+    if (entry.details?.handed_to) {
+      console.log(chalk2.gray(`  \u2192 handed to ${entry.details.handed_to}`));
+    }
+    if (entry.details?.symbols && entry.details.symbols.length > 0) {
+      console.log(chalk2.gray(`  symbols: ${entry.details.symbols.join(", ")}`));
+    }
+    console.log();
+  }
+  if (timeline.length > limit) {
+    console.log(chalk2.gray(`Showing ${limit} of ${timeline.length} entries. Use --limit to see more.
+`));
+  }
+}
+async function teamResetCommand(targetPath, options) {
+  const rootDir = targetPath ? path3.resolve(targetPath) : process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Team not configured" }));
+    } else {
+      console.log(chalk2.yellow("\nTeam not configured. Run `paradigm team init` first.\n"));
+    }
+    return;
+  }
+  const state = loadTeamState(rootDir);
+  const pending = getPendingHandoffs(rootDir);
+  if (!options.force && (state.current || pending.length > 0)) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Has pending work",
+        current: state.current,
+        pending_handoffs: pending.length
+      }));
+    } else {
+      console.log(chalk2.yellow("\n\u26A0 Cannot reset - there is pending work:\n"));
+      if (state.current) {
+        console.log(`  Current: ${state.current.agent} working on "${state.current.task}"`);
+      }
+      if (pending.length > 0) {
+        console.log(`  Pending handoffs: ${pending.length}`);
+      }
+      console.log(chalk2.gray("\nUse --force to reset anyway.\n"));
+    }
+    return;
+  }
+  const newState = {
+    current: null,
+    queue: [],
+    recent: [],
+    blocked: []
+  };
+  saveTeamState(rootDir, newState);
+  const handoffsDir = path3.join(getParadigmDir(rootDir), "handoffs");
+  if (options.force && fs2.existsSync(handoffsDir)) {
+    const files = fs2.readdirSync(handoffsDir);
+    for (const file of files) {
+      fs2.unlinkSync(path3.join(handoffsDir, file));
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, cleared_handoffs: options.force }));
+    return;
+  }
+  console.log(chalk2.green("\n\u2713 Team state reset\n"));
+  console.log(chalk2.gray("  Current agent: cleared"));
+  console.log(chalk2.gray("  Activity log: cleared"));
+  console.log(chalk2.gray("  Queue: cleared"));
+  if (options.force) {
+    console.log(chalk2.gray("  Handoff files: deleted"));
+  }
+  console.log(chalk2.gray("\nReady for fresh start. Run `paradigm team status` to verify.\n"));
+}
+
+export {
+  teamModelsCommand,
+  teamInitCommand,
+  teamStatusCommand,
+  teamHandoffCommand,
+  teamAcceptCommand,
+  teamCheckCommand,
+  teamHistoryCommand,
+  teamResetCommand
+};