panopticon-cli 0.4.0 → 0.4.4

package/dist/chunk-H45CLB7E.js

@@ -0,0 +1,2044 @@
+import {
+  AGENTS_DIR,
+  getProviderEnv,
+  getProviderForModel,
+  loadSettings
+} from "./chunk-7HHDVXBM.js";
+
+// src/lib/agents.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, appendFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/lib/tmux.ts
+import { execSync } from "child_process";
+import { writeFileSync, chmodSync } from "fs";
+function listSessions() {
+  try {
+    const output = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}|#{session_windows}"', {
+      encoding: "utf8"
+    });
+    return output.trim().split("\n").filter(Boolean).map((line) => {
+      const [name, created, attached, windows] = line.split("|");
+      return {
+        name,
+        created: new Date(parseInt(created) * 1e3),
+        attached: attached === "1",
+        windows: parseInt(windows)
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function sessionExists(name) {
+  try {
+    execSync(`tmux has-session -t ${name} 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createSession(name, cwd, initialCommand, options) {
+  const escapedCwd = cwd.replace(/"/g, '\\"');
+  let envFlags = "";
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      envFlags += ` -e ${key}="${value.replace(/"/g, '\\"')}"`;
+    }
+  }
+  if (initialCommand && (initialCommand.includes("`") || initialCommand.includes("\n") || initialCommand.length > 500)) {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+    execSync("sleep 0.5");
+    const tmpFile = `/tmp/pan-cmd-${name}.sh`;
+    writeFileSync(tmpFile, initialCommand);
+    chmodSync(tmpFile, "755");
+    execSync(`tmux send-keys -t ${name} "bash ${tmpFile}"`);
+    execSync(`tmux send-keys -t ${name} C-m`);
+  } else if (initialCommand) {
+    const cmd = `tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags} "${initialCommand.replace(/"/g, '\\"')}"`;
+    execSync(cmd);
+  } else {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+  }
+}
+function killSession(name) {
+  execSync(`tmux kill-session -t ${name}`);
+}
+function sendKeys(sessionName, keys) {
+  const escapedKeys = keys.replace(/"/g, '\\"');
+  execSync(`tmux send-keys -t ${sessionName} "${escapedKeys}"`);
+  execSync(`tmux send-keys -t ${sessionName} C-m`);
+}
+function getAgentSessions() {
+  return listSessions().filter((s) => s.name.startsWith("agent-"));
+}
+
+// src/lib/hooks.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+function getHookDir(agentId) {
+  return join(AGENTS_DIR, agentId);
+}
+function getHookFile(agentId) {
+  return join(getHookDir(agentId), "hook.json");
+}
+function getMailDir(agentId) {
+  return join(getHookDir(agentId), "mail");
+}
+function initHook(agentId) {
+  const hookDir = getHookDir(agentId);
+  const mailDir = getMailDir(agentId);
+  mkdirSync(hookDir, { recursive: true });
+  mkdirSync(mailDir, { recursive: true });
+  const hookFile = getHookFile(agentId);
+  if (!existsSync(hookFile)) {
+    const hook = {
+      agentId,
+      items: []
+    };
+    writeFileSync2(hookFile, JSON.stringify(hook, null, 2));
+  }
+}
+function getHook(agentId) {
+  const hookFile = getHookFile(agentId);
+  if (!existsSync(hookFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(hookFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function pushToHook(agentId, item) {
+  initHook(agentId);
+  const hook = getHook(agentId) || { agentId, items: [] };
+  const newItem = {
+    ...item,
+    id: `hook-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  hook.items.push(newItem);
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return newItem;
+}
+function checkHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook || hook.items.length === 0) {
+    const mailDir = getMailDir(agentId);
+    if (existsSync(mailDir)) {
+      const mails = readdirSync(mailDir).filter((f) => f.endsWith(".json"));
+      if (mails.length > 0) {
+        const mailItems = mails.map((file) => {
+          try {
+            const content = readFileSync(join(mailDir, file), "utf-8");
+            return JSON.parse(content);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        return {
+          hasWork: mailItems.length > 0,
+          urgentCount: mailItems.filter((i) => i.priority === "urgent").length,
+          items: mailItems
+        };
+      }
+    }
+    return { hasWork: false, urgentCount: 0, items: [] };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const activeItems = hook.items.filter((item) => {
+    if (item.expiresAt) {
+      return new Date(item.expiresAt) > now;
+    }
+    return true;
+  });
+  const priorityOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
+  activeItems.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return {
+    hasWork: activeItems.length > 0,
+    urgentCount: activeItems.filter((i) => i.priority === "urgent").length,
+    items: activeItems
+  };
+}
+function popFromHook(agentId, itemId) {
+  const hook = getHook(agentId);
+  if (!hook) return false;
+  const index = hook.items.findIndex((i) => i.id === itemId);
+  if (index === -1) return false;
+  hook.items.splice(index, 1);
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return true;
+}
+function clearHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook) return;
+  hook.items = [];
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+}
+function sendMail(toAgentId, from, message, priority = "normal") {
+  initHook(toAgentId);
+  const mailDir = getMailDir(toAgentId);
+  const mailItem = {
+    id: `mail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    type: "message",
+    priority,
+    source: from,
+    payload: { message },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync2(
+    join(mailDir, `${mailItem.id}.json`),
+    JSON.stringify(mailItem, null, 2)
+  );
+}
+function generateFixedPointPrompt(agentId) {
+  const { hasWork, urgentCount, items } = checkHook(agentId);
+  if (!hasWork) return null;
+  const lines = [
+    "# FPP: Work Found on Your Hook",
+    "",
+    '> "Any runnable action is a fixed point and must resolve before the system can rest."',
+    ""
+  ];
+  if (urgentCount > 0) {
+    lines.push(`\u26A0\uFE0F **${urgentCount} URGENT item(s) require immediate attention**`);
+    lines.push("");
+  }
+  lines.push(`## Pending Work Items (${items.length})`);
+  lines.push("");
+  for (const item of items) {
+    const priorityEmoji = {
+      urgent: "\u{1F534}",
+      high: "\u{1F7E0}",
+      normal: "\u{1F7E2}",
+      low: "\u26AA"
+    }[item.priority];
+    lines.push(`### ${priorityEmoji} ${item.type.toUpperCase()}: ${item.id}`);
+    lines.push(`- Source: ${item.source}`);
+    lines.push(`- Created: ${item.createdAt}`);
+    if (item.payload.issueId) {
+      lines.push(`- Issue: ${item.payload.issueId}`);
+    }
+    if (item.payload.message) {
+      lines.push(`- Message: ${item.payload.message}`);
+    }
+    if (item.payload.action) {
+      lines.push(`- Action: ${item.payload.action}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Execute these items in priority order. Use `bd hook pop <id>` after completing each item.");
+  return lines.join("\n");
+}
+
+// src/lib/cv.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+function getCVFile(agentId) {
+  return join2(AGENTS_DIR, agentId, "cv.json");
+}
+function getAgentCV(agentId) {
+  const cvFile = getCVFile(agentId);
+  if (existsSync2(cvFile)) {
+    try {
+      return JSON.parse(readFileSync2(cvFile, "utf-8"));
+    } catch {
+    }
+  }
+  const cv = {
+    agentId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString(),
+    runtime: "claude",
+    model: "sonnet",
+    stats: {
+      totalIssues: 0,
+      successCount: 0,
+      failureCount: 0,
+      abandonedCount: 0,
+      avgDuration: 0,
+      successRate: 0
+    },
+    skillsUsed: [],
+    recentWork: []
+  };
+  saveAgentCV(cv);
+  return cv;
+}
+function saveAgentCV(cv) {
+  const dir = join2(AGENTS_DIR, cv.agentId);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync3(getCVFile(cv.agentId), JSON.stringify(cv, null, 2));
+}
+function startWork(agentId, issueId, skills) {
+  const cv = getAgentCV(agentId);
+  const entry = {
+    issueId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    outcome: "in_progress",
+    skills
+  };
+  cv.recentWork.unshift(entry);
+  cv.stats.totalIssues++;
+  cv.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  if (skills) {
+    for (const skill of skills) {
+      if (!cv.skillsUsed.includes(skill)) {
+        cv.skillsUsed.push(skill);
+      }
+    }
+  }
+  if (cv.recentWork.length > 50) {
+    cv.recentWork = cv.recentWork.slice(0, 50);
+  }
+  saveAgentCV(cv);
+}
+function getAgentRankings() {
+  const rankings = [];
+  if (!existsSync2(AGENTS_DIR)) return rankings;
+  const dirs = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter(
+    (d) => d.isDirectory()
+  );
+  for (const dir of dirs) {
+    const cv = getAgentCV(dir.name);
+    if (cv.stats.totalIssues > 0) {
+      rankings.push({
+        agentId: dir.name,
+        successRate: cv.stats.successRate,
+        totalIssues: cv.stats.totalIssues,
+        avgDuration: cv.stats.avgDuration
+      });
+    }
+  }
+  rankings.sort((a, b) => {
+    if (b.successRate !== a.successRate) {
+      return b.successRate - a.successRate;
+    }
+    return b.totalIssues - a.totalIssues;
+  });
+  return rankings;
+}
+function formatCV(cv) {
+  const lines = [
+    `# Agent CV: ${cv.agentId}`,
+    "",
+    `Runtime: ${cv.runtime} (${cv.model})`,
+    `Created: ${cv.createdAt}`,
+    `Last Active: ${cv.lastActive}`,
+    "",
+    "## Statistics",
+    "",
+    `- Total Issues: ${cv.stats.totalIssues}`,
+    `- Success Rate: ${(cv.stats.successRate * 100).toFixed(1)}%`,
+    `- Successes: ${cv.stats.successCount}`,
+    `- Failures: ${cv.stats.failureCount}`,
+    `- Abandoned: ${cv.stats.abandonedCount}`,
+    `- Avg Duration: ${cv.stats.avgDuration} minutes`,
+    ""
+  ];
+  if (cv.skillsUsed.length > 0) {
+    lines.push("## Skills Used");
+    lines.push("");
+    lines.push(cv.skillsUsed.join(", "));
+    lines.push("");
+  }
+  if (cv.recentWork.length > 0) {
+    lines.push("## Recent Work");
+    lines.push("");
+    for (const work of cv.recentWork.slice(0, 10)) {
+      const statusIcon = {
+        success: "\u2713",
+        failed: "\u2717",
+        abandoned: "\u2298",
+        in_progress: "\u25CF"
+      }[work.outcome];
+      const duration = work.duration ? ` (${work.duration}m)` : "";
+      lines.push(`${statusIcon} ${work.issueId}${duration}`);
+      if (work.failureReason) {
+        lines.push(`  Reason: ${work.failureReason}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/lib/work-types.ts
+var WORK_TYPES = {
+  // Issue agent phases (6)
+  "issue-agent:exploration": {
+    phase: "exploration",
+    category: "issue-agent",
+    description: "Exploring codebase and understanding requirements"
+  },
+  "issue-agent:planning": {
+    phase: "planning",
+    category: "issue-agent",
+    description: "Planning implementation approach and architecture"
+  },
+  "issue-agent:implementation": {
+    phase: "implementation",
+    category: "issue-agent",
+    description: "Writing code to implement features or fixes"
+  },
+  "issue-agent:testing": {
+    phase: "testing",
+    category: "issue-agent",
+    description: "Running tests and verifying functionality"
+  },
+  "issue-agent:documentation": {
+    phase: "documentation",
+    category: "issue-agent",
+    description: "Writing documentation and updating docs"
+  },
+  "issue-agent:review-response": {
+    phase: "review-response",
+    category: "issue-agent",
+    description: "Responding to code review feedback"
+  },
+  // Specialist agents (3)
+  "specialist-review-agent": {
+    category: "specialist",
+    description: "Comprehensive code review specialist"
+  },
+  "specialist-test-agent": {
+    category: "specialist",
+    description: "Test generation and verification specialist"
+  },
+  "specialist-merge-agent": {
+    category: "specialist",
+    description: "Merge request finalization specialist"
+  },
+  // Subagents (4)
+  "subagent:explore": {
+    category: "subagent",
+    description: "Fast codebase exploration subagent"
+  },
+  "subagent:plan": {
+    category: "subagent",
+    description: "Implementation planning subagent"
+  },
+  "subagent:bash": {
+    category: "subagent",
+    description: "Command execution specialist subagent"
+  },
+  "subagent:general-purpose": {
+    category: "subagent",
+    description: "General-purpose task subagent"
+  },
+  // Convoy members (4)
+  "convoy:security-reviewer": {
+    category: "convoy",
+    description: "Security-focused code reviewer in convoy"
+  },
+  "convoy:performance-reviewer": {
+    category: "convoy",
+    description: "Performance-focused code reviewer in convoy"
+  },
+  "convoy:correctness-reviewer": {
+    category: "convoy",
+    description: "Correctness-focused code reviewer in convoy"
+  },
+  "convoy:synthesis-agent": {
+    category: "convoy",
+    description: "Synthesizes findings from convoy reviewers"
+  },
+  // Pre-work agents (4)
+  "prd-agent": {
+    category: "pre-work",
+    description: "Generates Product Requirement Documents"
+  },
+  "decomposition-agent": {
+    category: "pre-work",
+    description: "Breaks down work into tasks"
+  },
+  "triage-agent": {
+    category: "pre-work",
+    description: "Prioritizes and triages issues"
+  },
+  "planning-agent": {
+    category: "pre-work",
+    description: "Explores and plans implementation approach"
+  },
+  // CLI contexts (2)
+  "cli:interactive": {
+    category: "cli",
+    description: "Interactive CLI session"
+  },
+  "cli:quick-command": {
+    category: "cli",
+    description: "Quick one-off CLI commands"
+  }
+};
+function getAllWorkTypes() {
+  return Object.keys(WORK_TYPES);
+}
+function isValidWorkType(id) {
+  return id in WORK_TYPES;
+}
+function validateWorkType(id) {
+  if (!isValidWorkType(id)) {
+    throw new Error(
+      `Invalid work type ID: ${id}. Valid types: ${getAllWorkTypes().join(", ")}`
+    );
+  }
+}
+
+// src/lib/model-fallback.ts
+var MODEL_PROVIDERS = {
+  // Anthropic models
+  "claude-opus-4-5": "anthropic",
+  "claude-sonnet-4-5": "anthropic",
+  "claude-haiku-4-5": "anthropic",
+  // OpenAI models
+  "gpt-5.2-codex": "openai",
+  "o3-deep-research": "openai",
+  "gpt-4o": "openai",
+  "gpt-4o-mini": "openai",
+  // Google models
+  "gemini-3-pro-preview": "google",
+  "gemini-3-flash-preview": "google",
+  "gemini-2.5-pro": "google",
+  "gemini-2.5-flash": "google",
+  // Z.AI models
+  "glm-4.7": "zai",
+  "glm-4.7-flash": "zai",
+  // Kimi models
+  "kimi-k2": "kimi",
+  "kimi-k2.5": "kimi"
+};
+var FALLBACK_MAP = {
+  // OpenAI → Anthropic
+  "gpt-5.2-codex": "claude-sonnet-4-5",
+  // Premium code model → Sonnet
+  "o3-deep-research": "claude-sonnet-4-5",
+  // Premium research model → Sonnet
+  "gpt-4o": "claude-sonnet-4-5",
+  // Flagship model → Sonnet
+  "gpt-4o-mini": "claude-haiku-4-5",
+  // Economy model → Haiku
+  // Google → Anthropic
+  "gemini-3-pro-preview": "claude-sonnet-4-5",
+  // Premium model → Sonnet
+  "gemini-3-flash-preview": "claude-haiku-4-5",
+  // Fast model → Haiku
+  // Z.AI → Anthropic
+  "glm-4.7": "claude-haiku-4-5",
+  // Standard model → Haiku
+  "glm-4.7-flash": "claude-haiku-4-5",
+  // Fast model → Haiku
+  // Kimi → Anthropic
+  "kimi-k2": "claude-sonnet-4-5",
+  // Good balance model → Sonnet
+  "kimi-k2.5": "claude-sonnet-4-5"
+  // Premium model → Sonnet
+};
+var DEFAULT_FALLBACK = "claude-sonnet-4-5";
+function getModelProvider(modelId) {
+  return MODEL_PROVIDERS[modelId];
+}
+function getModelsByProvider(provider) {
+  return Object.entries(MODEL_PROVIDERS).filter(([_, p]) => p === provider).map(([modelId]) => modelId);
+}
+function isProviderEnabled(provider, enabledProviders) {
+  if (provider === "anthropic") return true;
+  return enabledProviders.has(provider);
+}
+function applyFallback(modelId, enabledProviders) {
+  const provider = getModelProvider(modelId);
+  if (isProviderEnabled(provider, enabledProviders)) {
+    return modelId;
+  }
+  const fallback = FALLBACK_MAP[modelId] || DEFAULT_FALLBACK;
+  console.warn(
+    `Model ${modelId} requires ${provider} API key - falling back to ${fallback}`
+  );
+  return fallback;
+}
+
+// src/lib/config-yaml.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import yaml from "js-yaml";
+var DEFAULT_CONFIG = {
+  enabledProviders: /* @__PURE__ */ new Set(["anthropic"]),
+  // Only Anthropic by default
+  apiKeys: {},
+  overrides: {},
+  geminiThinkingLevel: 3
+};
+var GLOBAL_CONFIG_PATH = join3(homedir(), ".panopticon", "config.yaml");
+function normalizeProviderConfig(providerConfig, fallbackKey) {
+  if (providerConfig === void 0) {
+    return { enabled: false };
+  }
+  if (typeof providerConfig === "boolean") {
+    return { enabled: providerConfig, api_key: fallbackKey };
+  }
+  return {
+    enabled: providerConfig.enabled,
+    api_key: providerConfig.api_key || fallbackKey
+  };
+}
+function resolveEnvVar(value) {
+  if (!value) return void 0;
+  return value.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/g, (match, varName) => {
+    const envValue = process.env[varName];
+    return envValue !== void 0 ? envValue : match;
+  });
+}
+function loadYamlFile(filePath) {
+  if (!existsSync3(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const parsed = yaml.load(content);
+    return parsed || {};
+  } catch (error) {
+    console.error(`Error loading YAML config from ${filePath}:`, error);
+    return null;
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== "/") {
+    if (existsSync3(join3(currentDir, ".git"))) {
+      return currentDir;
+    }
+    currentDir = join3(currentDir, "..");
+  }
+  return null;
+}
+function loadProjectConfig() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    return null;
+  }
+  const projectConfigPath = join3(projectRoot, ".panopticon.yaml");
+  return loadYamlFile(projectConfigPath);
+}
+function loadGlobalConfig() {
+  return loadYamlFile(GLOBAL_CONFIG_PATH);
+}
+function mergeConfigs(...configs) {
+  const result = {
+    ...DEFAULT_CONFIG,
+    enabledProviders: new Set(DEFAULT_CONFIG.enabledProviders)
+  };
+  const validConfigs = configs.filter((c) => c !== null);
+  for (const config of validConfigs.reverse()) {
+    if (config.models?.providers) {
+      const providers = config.models.providers;
+      const legacyKeys = config.api_keys || {};
+      result.enabledProviders.add("anthropic");
+      const openai = normalizeProviderConfig(providers.openai, legacyKeys.openai);
+      if (openai.enabled) {
+        result.enabledProviders.add("openai");
+        if (openai.api_key) {
+          result.apiKeys.openai = resolveEnvVar(openai.api_key);
+        }
+      }
+      const google = normalizeProviderConfig(providers.google, legacyKeys.google);
+      if (google.enabled) {
+        result.enabledProviders.add("google");
+        if (google.api_key) {
+          result.apiKeys.google = resolveEnvVar(google.api_key);
+        }
+      }
+      const zai = normalizeProviderConfig(providers.zai, legacyKeys.zai);
+      if (zai.enabled) {
+        result.enabledProviders.add("zai");
+        if (zai.api_key) {
+          result.apiKeys.zai = resolveEnvVar(zai.api_key);
+        }
+      }
+      const kimi = normalizeProviderConfig(providers.kimi, legacyKeys.kimi);
+      if (kimi.enabled) {
+        result.enabledProviders.add("kimi");
+        if (kimi.api_key) {
+          result.apiKeys.kimi = resolveEnvVar(kimi.api_key);
+        }
+      }
+    }
+    if (config.api_keys) {
+      if (config.api_keys.openai) {
+        result.apiKeys.openai = resolveEnvVar(config.api_keys.openai);
+        result.enabledProviders.add("openai");
+      }
+      if (config.api_keys.google) {
+        result.apiKeys.google = resolveEnvVar(config.api_keys.google);
+        result.enabledProviders.add("google");
+      }
+      if (config.api_keys.zai) {
+        result.apiKeys.zai = resolveEnvVar(config.api_keys.zai);
+        result.enabledProviders.add("zai");
+      }
+      if (config.api_keys.kimi) {
+        result.apiKeys.kimi = resolveEnvVar(config.api_keys.kimi);
+        result.enabledProviders.add("kimi");
+      }
+    }
+    if (config.models?.overrides) {
+      result.overrides = {
+        ...result.overrides,
+        ...config.models.overrides
+      };
+    }
+    if (config.models?.gemini_thinking_level) {
+      result.geminiThinkingLevel = config.models.gemini_thinking_level;
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig();
+  const config = mergeConfigs(projectConfig, globalConfig);
+  if (process.env.OPENAI_API_KEY && !config.apiKeys.openai) {
+    config.apiKeys.openai = process.env.OPENAI_API_KEY;
+    config.enabledProviders.add("openai");
+  }
+  if (process.env.GOOGLE_API_KEY && !config.apiKeys.google) {
+    config.apiKeys.google = process.env.GOOGLE_API_KEY;
+    config.enabledProviders.add("google");
+  }
+  if (process.env.ZAI_API_KEY && !config.apiKeys.zai) {
+    config.apiKeys.zai = process.env.ZAI_API_KEY;
+    config.enabledProviders.add("zai");
+  }
+  if (process.env.KIMI_API_KEY && !config.apiKeys.kimi) {
+    config.apiKeys.kimi = process.env.KIMI_API_KEY;
+    config.enabledProviders.add("kimi");
+  }
+  return config;
+}
+
+// src/lib/model-capabilities.ts
+var MODEL_CAPABILITIES = {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ANTHROPIC MODELS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "claude-opus-4-5": {
+    model: "claude-opus-4-5",
+    provider: "anthropic",
+    displayName: "Claude Opus 4.5",
+    costPer1MTokens: 45,
+    // $15 in / $75 out → avg ~$45
+    contextWindow: 2e5,
+    skills: {
+      "code-generation": 96,
+      // 80.9% SWE-bench (first >80%), 89.4% Aider Polyglot
+      "code-review": 98,
+      debugging: 97,
+      planning: 99,
+      // User confirms: "Opus 4.5 planning for sure"
+      documentation: 95,
+      testing: 92,
+      security: 98,
+      // Best for security review
+      performance: 90,
+      synthesis: 98,
+      // Best for combining info across domains
+      speed: 40,
+      // Slower but 76% more token efficient
+      "context-length": 95
+    },
+    notes: "First to exceed 80% SWE-bench. Best for planning, security, complex reasoning. Leads 7/8 languages."
+  },
+  "claude-sonnet-4-5": {
+    model: "claude-sonnet-4-5",
+    provider: "anthropic",
+    displayName: "Claude Sonnet 4.5",
+    costPer1MTokens: 9,
+    // $3 in / $15 out → avg ~$9
+    contextWindow: 2e5,
+    skills: {
+      "code-generation": 92,
+      // 77.2% SWE-bench (82% parallel), beats GPT-5 Codex (74.5%)
+      "code-review": 92,
+      debugging: 90,
+      planning: 88,
+      documentation: 90,
+      // 100% AIME with Python
+      testing: 90,
+      // 50% Terminal-Bench, 61.4% OSWorld
+      security: 85,
+      performance: 85,
+      synthesis: 88,
+      speed: 70,
+      "context-length": 95
+    },
+    notes: "Best value: 77.2% SWE-bench at 1/5th Opus cost. Beats GPT-5 Codex."
+  },
+  "claude-haiku-4-5": {
+    model: "claude-haiku-4-5",
+    provider: "anthropic",
+    displayName: "Claude Haiku 4.5",
+    costPer1MTokens: 4,
+    // $0.80 in / $4 out → avg ~$2.4
+    contextWindow: 2e5,
+    skills: {
+      "code-generation": 75,
+      "code-review": 72,
+      debugging: 70,
+      planning: 65,
+      documentation: 75,
+      testing: 70,
+      security: 60,
+      performance: 65,
+      synthesis: 68,
+      speed: 95,
+      // Fastest Anthropic
+      "context-length": 95
+    },
+    notes: "Fast and cheap, good for simple tasks and exploration"
+  },
+  // ═══════════════════════════════════════════════════════════════════════════
+  // OPENAI MODELS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "gpt-5.2-codex": {
+    model: "gpt-5.2-codex",
+    provider: "openai",
+    displayName: "GPT-5.2 Codex",
+    costPer1MTokens: 75,
+    // Premium tier ~$75/M
+    contextWindow: 128e3,
+    skills: {
+      "code-generation": 95,
+      // 80% SWE-bench Verified, 55.6% SWE-bench Pro
+      "code-review": 90,
+      debugging: 92,
+      // 92.4% GPQA Diamond
+      planning: 88,
+      documentation: 85,
+      testing: 90,
+      security: 85,
+      performance: 88,
+      // 52.9% ARC-AGI-2 (best reasoning)
+      synthesis: 88,
+      // 100% AIME 2025 without tools
+      speed: 55,
+      "context-length": 75
+    },
+    notes: "Premium coding: 80% SWE-bench. Best raw reasoning (52.9% ARC-AGI-2). Expensive."
+  },
+  "o3-deep-research": {
+    model: "o3-deep-research",
+    provider: "openai",
+    displayName: "O3 Deep Research",
+    costPer1MTokens: 100,
+    // Expensive reasoning model
+    contextWindow: 2e5,
+    skills: {
+      "code-generation": 85,
+      "code-review": 95,
+      debugging: 98,
+      // Best for debugging
+      planning: 95,
+      documentation: 88,
+      testing: 85,
+      security: 92,
+      performance: 92,
+      synthesis: 95,
+      speed: 20,
+      // Very slow (reasoning chains)
+      "context-length": 95
+    },
+    notes: "Deep reasoning model, excellent for complex debugging and analysis"
+  },
+  "gpt-4o": {
+    model: "gpt-4o",
+    provider: "openai",
+    displayName: "GPT-4o",
+    costPer1MTokens: 15,
+    // $5 in / $15 out
+    contextWindow: 128e3,
+    skills: {
+      "code-generation": 88,
+      "code-review": 85,
+      debugging: 85,
+      planning: 82,
+      documentation: 88,
+      testing: 82,
+      security: 78,
+      performance: 80,
+      synthesis: 85,
+      speed: 75,
+      "context-length": 75
+    },
+    notes: "Good all-rounder, competitive with Sonnet"
+  },
+  "gpt-4o-mini": {
+    model: "gpt-4o-mini",
+    provider: "openai",
+    displayName: "GPT-4o Mini",
+    costPer1MTokens: 1,
+    // Very cheap
+    contextWindow: 128e3,
+    skills: {
+      "code-generation": 72,
+      "code-review": 68,
+      debugging: 65,
+      planning: 60,
+      documentation: 70,
+      testing: 65,
+      security: 55,
+      performance: 60,
+      synthesis: 62,
+      speed: 92,
+      "context-length": 75
+    },
+    notes: "Budget option, good for simple tasks"
+  },
+  // ═══════════════════════════════════════════════════════════════════════════
+  // GOOGLE MODELS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "gemini-3-pro-preview": {
+    model: "gemini-3-pro-preview",
+    provider: "google",
+    displayName: "Gemini 3 Pro",
+    costPer1MTokens: 12,
+    // $4.2 in / $18.9 out
+    contextWindow: 1e6,
+    // 1M context!
+    skills: {
+      "code-generation": 90,
+      // 2439 Elo LiveCodeBench Pro (first >1500 on LMArena)
+      "code-review": 88,
+      debugging: 85,
+      planning: 85,
+      documentation: 88,
+      testing: 85,
+      // ~95% AIME 2025
+      security: 78,
+      performance: 85,
+      // Strong multimodal
+      synthesis: 90,
+      // Best for combining large codebases
+      speed: 80,
+      "context-length": 100
+      // Best context - 1M tokens
+    },
+    notes: "First to exceed 1500 Elo on LMArena. Best for large codebase analysis with 1M context."
+  },
+  "gemini-3-flash-preview": {
+    model: "gemini-3-flash-preview",
+    provider: "google",
+    displayName: "Gemini 3 Flash",
+    costPer1MTokens: 0.5,
+    // Very cheap
+    contextWindow: 1e6,
+    skills: {
+      "code-generation": 75,
+      "code-review": 70,
+      debugging: 68,
+      planning: 62,
+      documentation: 72,
+      testing: 68,
+      security: 55,
+      performance: 65,
+      synthesis: 70,
+      speed: 98,
+      // Fastest overall
+      "context-length": 100
+    },
+    notes: "Extremely fast and cheap, huge context, great for exploration"
+  },
+  "gemini-2.5-pro": {
+    model: "gemini-2.5-pro",
+    provider: "google",
+    displayName: "Gemini 2.5 Pro",
+    costPer1MTokens: 12,
+    contextWindow: 1e6,
+    skills: {
+      "code-generation": 92,
+      "code-review": 90,
+      debugging: 88,
+      planning: 88,
+      documentation: 90,
+      testing: 87,
+      security: 82,
+      performance: 88,
+      synthesis: 92,
+      speed: 75,
+      "context-length": 100
+    },
+    notes: "Advanced reasoning and code capabilities with 1M context"
+  },
+  "gemini-2.5-flash": {
+    model: "gemini-2.5-flash",
+    provider: "google",
+    displayName: "Gemini 2.5 Flash",
+    costPer1MTokens: 0.6,
+    contextWindow: 1e6,
+    skills: {
+      "code-generation": 78,
+      "code-review": 73,
+      debugging: 70,
+      planning: 65,
+      documentation: 75,
+      testing: 70,
+      security: 58,
+      performance: 68,
+      synthesis: 73,
+      speed: 95,
+      "context-length": 100
+    },
+    notes: "Fast and efficient with large context support"
+  },
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Z.AI MODELS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "glm-4.7": {
+    model: "glm-4.7",
+    provider: "zai",
+    displayName: "GLM 4.7",
+    costPer1MTokens: 5,
+    contextWindow: 2e5,
+    // 200K context, 128K output
+    skills: {
+      "code-generation": 88,
+      // 73.8% SWE-bench, 84.9 LiveCodeBench v6 (open-source SOTA)
+      "code-review": 85,
+      debugging: 85,
+      // Strong debugging with Interleaved Thinking
+      planning: 82,
+      // 95.7% AIME 2025 (beats Gemini 3 & GPT-5.1)
+      documentation: 80,
+      testing: 82,
+      // 87.4 τ²-Bench (SOTA for tool use)
+      security: 72,
+      performance: 78,
+      synthesis: 85,
+      // Preserved Thinking retains context across turns
+      speed: 80,
+      "context-length": 95
+      // 200K context
+    },
+    notes: "Top open-source for agentic coding. 73.8% SWE-bench, best tool use. 400B params with Interleaved Thinking."
+  },
+  "glm-4.7-flash": {
+    model: "glm-4.7-flash",
+    provider: "zai",
+    displayName: "GLM 4.7 Flash",
+    costPer1MTokens: 1.5,
+    contextWindow: 128e3,
+    skills: {
+      "code-generation": 72,
+      "code-review": 68,
+      debugging: 65,
+      planning: 62,
+      documentation: 70,
+      testing: 65,
+      security: 55,
+      performance: 62,
+      synthesis: 65,
+      speed: 92,
+      // Fast inference
+      "context-length": 75
+    },
+    notes: "Fast and affordable. Good for quick iterations and exploration."
+  },
+  // ═══════════════════════════════════════════════════════════════════════════
+  // KIMI MODELS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "kimi-k2": {
+    model: "kimi-k2",
+    provider: "kimi",
+    displayName: "Kimi K2",
+    costPer1MTokens: 1.4,
+    // $0.16 in / $2.63 out → very cheap
+    contextWindow: 131e3,
+    skills: {
+      "code-generation": 82,
+      // 65.8% SWE-bench (beats GPT-4.1 at 54.6%)
+      "code-review": 80,
+      debugging: 78,
+      planning: 75,
+      documentation: 80,
+      testing: 75,
+      security: 70,
+      performance: 72,
+      synthesis: 78,
+      speed: 80,
+      "context-length": 75
+    },
+    notes: "Strong value: 65.8% SWE-bench at very low cost. Good for routine tasks."
+  },
+  "kimi-k2.5": {
+    model: "kimi-k2.5",
+    provider: "kimi",
+    displayName: "Kimi K2.5",
+    costPer1MTokens: 8,
+    // ~5.1x cheaper than GPT-5.2
+    contextWindow: 256e3,
+    skills: {
+      "code-generation": 92,
+      // 76.8% SWE-bench, 85 LiveCodeBench v6
+      "code-review": 90,
+      debugging: 90,
+      // Strong analytical capabilities
+      planning: 88,
+      // User confirms "highly capable"
+      documentation: 88,
+      testing: 88,
+      // 92% coding accuracy
+      security: 82,
+      performance: 85,
+      synthesis: 92,
+      // Can coordinate 100 sub-agents, 1500 tool calls
+      speed: 75,
+      // MoE: 1T total params, 32B active
+      "context-length": 98
+      // 256K context
+    },
+    notes: "Best open-source coding model. 5x cheaper than GPT-5.2. Excellent for frontend dev and multi-agent orchestration."
+  }
+};
+function getModelCapability(model) {
+  return MODEL_CAPABILITIES[model];
+}
+
+// src/lib/smart-model-selector.ts
+var WORK_TYPE_REQUIREMENTS = {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ISSUE AGENT PHASES
+  // ═══════════════════════════════════════════════════════════════════════════
+  "issue-agent:exploration": [
+    { skill: "speed", weight: 0.4 },
+    // Need fast exploration
+    { skill: "context-length", weight: 0.3 },
+    // Large codebases
+    { skill: "synthesis", weight: 0.3 }
+    // Understanding structure
+  ],
+  "issue-agent:planning": [
+    { skill: "planning", weight: 0.5 },
+    // Primary skill
+    { skill: "code-review", weight: 0.2 },
+    // Understanding existing code
+    { skill: "synthesis", weight: 0.3 }
+    // Combining requirements
+  ],
+  "issue-agent:implementation": [
+    { skill: "code-generation", weight: 0.6 },
+    // Primary skill
+    { skill: "debugging", weight: 0.2 },
+    // Avoiding bugs
+    { skill: "testing", weight: 0.2 }
+    // Writing testable code
+  ],
+  "issue-agent:testing": [
+    { skill: "testing", weight: 0.5 },
+    // Primary skill
+    { skill: "code-generation", weight: 0.3 },
+    // Writing test code
+    { skill: "debugging", weight: 0.2 }
+    // Finding edge cases
+  ],
+  "issue-agent:documentation": [
+    { skill: "documentation", weight: 0.6 },
+    // Primary skill
+    { skill: "synthesis", weight: 0.3 },
+    // Summarizing
+    { skill: "speed", weight: 0.1 }
+    // Fast iteration
+  ],
+  "issue-agent:review-response": [
+    { skill: "code-review", weight: 0.4 },
+    // Understanding feedback
+    { skill: "code-generation", weight: 0.3 },
+    // Making fixes
+    { skill: "debugging", weight: 0.3 }
+    // Finding issues
+  ],
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SPECIALIST AGENTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "specialist-review-agent": [
+    { skill: "code-review", weight: 0.5 },
+    // Primary skill
+    { skill: "security", weight: 0.25 },
+    // Security awareness
+    { skill: "performance", weight: 0.25 }
+    // Performance awareness
+  ],
+  "specialist-test-agent": [
+    { skill: "testing", weight: 0.5 },
+    // Primary skill
+    { skill: "code-generation", weight: 0.3 },
+    // Writing tests
+    { skill: "debugging", weight: 0.2 }
+    // Finding issues
+  ],
+  "specialist-merge-agent": [
+    { skill: "code-review", weight: 0.4 },
+    // Understanding conflicts
+    { skill: "synthesis", weight: 0.3 },
+    // Merging changes
+    { skill: "debugging", weight: 0.3 }
+    // Resolving issues
+  ],
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUBAGENTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "subagent:explore": [
+    { skill: "speed", weight: 0.5 },
+    // Need speed
+    { skill: "context-length", weight: 0.3 },
+    // Large scope
+    { skill: "synthesis", weight: 0.2 }
+    // Quick understanding
+  ],
+  "subagent:plan": [
+    { skill: "planning", weight: 0.5 },
+    // Primary skill
+    { skill: "synthesis", weight: 0.3 },
+    // Combining info
+    { skill: "speed", weight: 0.2 }
+    // Quick iteration
+  ],
+  "subagent:bash": [
+    { skill: "speed", weight: 0.6 },
+    // Fast execution
+    { skill: "code-generation", weight: 0.3 },
+    // Command generation
+    { skill: "debugging", weight: 0.1 }
+    // Error handling
+  ],
+  "subagent:general-purpose": [
+    { skill: "speed", weight: 0.3 },
+    // Balanced
+    { skill: "synthesis", weight: 0.3 },
+    // General understanding
+    { skill: "code-generation", weight: 0.4 }
+    // General tasks
+  ],
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CONVOY MEMBERS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "convoy:security-reviewer": [
+    { skill: "security", weight: 0.7 },
+    // PRIMARY - never compromise
+    { skill: "code-review", weight: 0.2 },
+    // Code understanding
+    { skill: "debugging", weight: 0.1 }
+    // Finding vulnerabilities
+  ],
+  "convoy:performance-reviewer": [
+    { skill: "performance", weight: 0.6 },
+    // Primary skill
+    { skill: "code-review", weight: 0.3 },
+    // Code understanding
+    { skill: "debugging", weight: 0.1 }
+    // Finding bottlenecks
+  ],
+  "convoy:correctness-reviewer": [
+    { skill: "code-review", weight: 0.4 },
+    // Primary skill
+    { skill: "debugging", weight: 0.4 },
+    // Finding bugs
+    { skill: "testing", weight: 0.2 }
+    // Test coverage
+  ],
+  "convoy:synthesis-agent": [
+    { skill: "synthesis", weight: 0.6 },
+    // Primary skill
+    { skill: "documentation", weight: 0.2 },
+    // Clear writing
+    { skill: "planning", weight: 0.2 }
+    // Organizing findings
+  ],
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRE-WORK AGENTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "prd-agent": [
+    { skill: "documentation", weight: 0.5 },
+    // Primary skill
+    { skill: "planning", weight: 0.3 },
+    // Structure
+    { skill: "synthesis", weight: 0.2 }
+    // Combining requirements
+  ],
+  "decomposition-agent": [
+    { skill: "planning", weight: 0.5 },
+    // Primary skill
+    { skill: "synthesis", weight: 0.3 },
+    // Breaking down
+    { skill: "documentation", weight: 0.2 }
+    // Clear tasks
+  ],
+  "triage-agent": [
+    { skill: "speed", weight: 0.4 },
+    // Quick decisions
+    { skill: "synthesis", weight: 0.3 },
+    // Understanding scope
+    { skill: "planning", weight: 0.3 }
+    // Prioritization
+  ],
+  "planning-agent": [
+    { skill: "planning", weight: 0.5 },
+    // Primary skill
+    { skill: "code-review", weight: 0.3 },
+    // Understanding codebase
+    { skill: "synthesis", weight: 0.2 }
+    // Combining approaches
+  ],
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CLI CONTEXTS
+  // ═══════════════════════════════════════════════════════════════════════════
+  "cli:interactive": [
+    { skill: "speed", weight: 0.4 },
+    // Responsive
+    { skill: "synthesis", weight: 0.3 },
+    // Understanding context
+    { skill: "code-generation", weight: 0.3 }
+    // Quick code
+  ],
+  "cli:quick-command": [
+    { skill: "speed", weight: 0.7 },
+    // Must be fast
+    { skill: "code-generation", weight: 0.2 },
+    // Simple generation
+    { skill: "synthesis", weight: 0.1 }
+    // Quick understanding
+  ]
+};
+function calculateSkillScore(model, requirements) {
+  const cap = getModelCapability(model);
+  let totalScore = 0;
+  let totalWeight = 0;
+  for (const req of requirements) {
+    totalScore += cap.skills[req.skill] * req.weight;
+    totalWeight += req.weight;
+  }
+  return totalWeight > 0 ? totalScore / totalWeight : 0;
+}
+function calculateSelectionScore(model, skillScore) {
+  return skillScore;
+}
+function selectModel(workType, availableModels, options = {}) {
+  const { minCapability = 50, forceModel } = options;
+  if (forceModel) {
+    if (availableModels.includes(forceModel)) {
+      return {
+        model: forceModel,
+        score: 100,
+        reason: `Forced selection: ${forceModel}`,
+        candidates: [{ model: forceModel, score: 100, available: true }]
+      };
+    }
+  }
+  const requirements = WORK_TYPE_REQUIREMENTS[workType];
+  const allModels = Object.keys(MODEL_CAPABILITIES);
+  const candidates = allModels.map((model) => {
+    const skillScore = calculateSkillScore(model, requirements);
+    const selectionScore = calculateSelectionScore(model, skillScore);
+    const available = availableModels.includes(model);
+    return {
+      model,
+      skillScore,
+      score: selectionScore,
+      available
+    };
+  });
+  const eligible = candidates.filter(
+    (c) => c.available && c.skillScore >= minCapability
+  );
+  eligible.sort((a, b) => b.score - a.score);
+  if (eligible.length === 0) {
+    const fallback = candidates.filter((c) => c.available).sort((a, b) => b.score - a.score)[0];
+    if (!fallback) {
+      return {
+        model: "claude-sonnet-4-5",
+        score: 0,
+        reason: "No models available, falling back to default",
+        candidates: candidates.map((c) => ({
+          model: c.model,
+          score: c.score,
+          available: c.available
+        }))
+      };
+    }
+    return {
+      model: fallback.model,
+      score: fallback.score,
+      reason: `Best available (below min threshold): ${fallback.model}`,
+      candidates: candidates.map((c) => ({
+        model: c.model,
+        score: c.score,
+        available: c.available
+      }))
+    };
+  }
+  const selected = eligible[0];
+  const cap = getModelCapability(selected.model);
+  const topSkills = requirements.sort((a, b) => b.weight - a.weight).slice(0, 2).map((r) => r.skill);
+  const reason = `Best for ${workType}: ${cap.displayName} (${topSkills.join(", ")}: ${Math.round(selected.skillScore)}, cost: $${cap.costPer1MTokens}/1M)`;
+  return {
+    model: selected.model,
+    score: selected.score,
+    reason,
+    candidates: candidates.map((c) => ({
+      model: c.model,
+      score: c.score,
+      available: c.available
+    }))
+  };
+}
+
+// src/lib/work-type-router.ts
+var WorkTypeRouter = class {
+  config;
+  availableModels = null;
+  constructor(config) {
+    this.config = config || loadConfig();
+  }
+  /**
+   * Get list of available models based on enabled providers
+   */
+  getAvailableModels() {
+    if (this.availableModels) {
+      return this.availableModels;
+    }
+    const available = [];
+    for (const provider of this.config.enabledProviders) {
+      available.push(...getModelsByProvider(provider));
+    }
+    this.availableModels = available;
+    return available;
+  }
+  /**
+   * Get model for a specific work type
+   *
+   * Resolution order:
+   * 1. Per-project/global override (if configured)
+   * 2. Smart selection (capability-based)
+   */
+  getModel(workTypeId) {
+    validateWorkType(workTypeId);
+    let model;
+    let source;
+    let originalModel;
+    let selection;
+    if (this.config.overrides[workTypeId]) {
+      model = this.config.overrides[workTypeId];
+      source = "override";
+      selection = {
+        score: 100,
+        reason: `Explicit override: ${model}`
+      };
+    } else {
+      const availableModels = this.getAvailableModels();
+      const result = selectModel(workTypeId, availableModels);
+      model = result.model;
+      source = "smart";
+      selection = {
+        score: result.score,
+        reason: result.reason
+      };
+    }
+    originalModel = model;
+    model = applyFallback(model, this.config.enabledProviders);
+    return {
+      model,
+      workType: workTypeId,
+      source,
+      usedFallback: model !== originalModel,
+      originalModel: model !== originalModel ? originalModel : void 0,
+      selection
+    };
+  }
+  /**
+   * Get just the model ID for a work type (convenience method)
+   */
+  getModelId(workTypeId) {
+    return this.getModel(workTypeId).model;
+  }
+  /**
+   * Check if a work type has an override configured
+   */
+  hasOverride(workTypeId) {
+    return workTypeId in this.config.overrides;
+  }
+  /**
+   * Get the set of enabled providers
+   */
+  getEnabledProviders() {
+    return this.config.enabledProviders;
+  }
+  /**
+   * Get all configured overrides
+   */
+  getOverrides() {
+    return { ...this.config.overrides };
+  }
+  /**
+   * Get API keys configuration
+   */
+  getApiKeys() {
+    return { ...this.config.apiKeys };
+  }
+  /**
+   * Get Gemini thinking level
+   */
+  getGeminiThinkingLevel() {
+    return this.config.geminiThinkingLevel;
+  }
+  /**
+   * Reload configuration from disk
+   */
+  reloadConfig() {
+    this.config = loadConfig();
+    this.availableModels = null;
+  }
+  /**
+   * Get debug information about current configuration
+   */
+  getDebugInfo() {
+    return {
+      enabledProviders: Array.from(this.config.enabledProviders),
+      availableModelCount: this.getAvailableModels().length,
+      overrideCount: Object.keys(this.config.overrides).length,
+      hasApiKeys: {
+        openai: !!this.config.apiKeys.openai,
+        google: !!this.config.apiKeys.google,
+        zai: !!this.config.apiKeys.zai,
+        kimi: !!this.config.apiKeys.kimi
+      }
+    };
+  }
+};
+var globalRouter = null;
+function getGlobalRouter() {
+  if (!globalRouter) {
+    globalRouter = new WorkTypeRouter();
+  }
+  return globalRouter;
+}
+function getModelId(workTypeId) {
+  return getGlobalRouter().getModelId(workTypeId);
+}
+
+// src/lib/agents.ts
+var execAsync = promisify(exec);
+function getReadySignalPath(agentId) {
+  return join4(getAgentDir(agentId), "ready.json");
+}
+function clearReadySignal(agentId) {
+  const readyPath = getReadySignalPath(agentId);
+  if (existsSync4(readyPath)) {
+    try {
+      unlinkSync2(readyPath);
+    } catch {
+    }
+  }
+}
+async function waitForReadySignal(agentId, timeoutSeconds = 30) {
+  const readyPath = getReadySignalPath(agentId);
+  for (let i = 0; i < timeoutSeconds; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    if (existsSync4(readyPath)) {
+      try {
+        const content = readFileSync4(readyPath, "utf-8");
+        const signal = JSON.parse(content);
+        if (signal.ready === true) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function getAgentDir(agentId) {
+  return join4(AGENTS_DIR, agentId);
+}
+function getAgentState(agentId) {
+  const stateFile = join4(getAgentDir(agentId), "state.json");
+  if (!existsSync4(stateFile)) return null;
+  const content = readFileSync4(stateFile, "utf8");
+  return JSON.parse(content);
+}
+function saveAgentState(state) {
+  const dir = getAgentDir(state.id);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync4(
+    join4(dir, "state.json"),
+    JSON.stringify(state, null, 2)
+  );
+}
+function getAgentRuntimeState(agentId) {
+  const stateFile = join4(getAgentDir(agentId), "state.json");
+  if (!existsSync4(stateFile)) {
+    return {
+      state: "uninitialized",
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const content = readFileSync4(stateFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveAgentRuntimeState(agentId, state) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  const existing = getAgentRuntimeState(agentId);
+  const merged = {
+    ...existing || { state: "uninitialized", lastActivity: (/* @__PURE__ */ new Date()).toISOString() },
+    ...state
+  };
+  writeFileSync4(
+    join4(dir, "state.json"),
+    JSON.stringify(merged, null, 2)
+  );
+}
+function appendActivity(agentId, entry) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  const activityFile = join4(dir, "activity.jsonl");
+  appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+  if (existsSync4(activityFile)) {
+    try {
+      const lines = readFileSync4(activityFile, "utf8").trim().split("\n");
+      if (lines.length > 100) {
+        const trimmed = lines.slice(-100);
+        writeFileSync4(activityFile, trimmed.join("\n") + "\n");
+      }
+    } catch (error) {
+    }
+  }
+}
+function getActivity(agentId, limit = 100) {
+  const activityFile = join4(getAgentDir(agentId), "activity.jsonl");
+  if (!existsSync4(activityFile)) {
+    return [];
+  }
+  try {
+    const lines = readFileSync4(activityFile, "utf8").trim().split("\n");
+    const entries = lines.filter((line) => line.trim()).map((line) => JSON.parse(line)).slice(-limit);
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function saveSessionId(agentId, sessionId) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync4(join4(dir, "session.id"), sessionId);
+}
+function getSessionId(agentId) {
+  const sessionFile = join4(getAgentDir(agentId), "session.id");
+  if (!existsSync4(sessionFile)) {
+    return null;
+  }
+  try {
+    return readFileSync4(sessionFile, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function determineModel(options) {
+  console.log(`[DEBUG] determineModel called with:`, { model: options.model, workType: options.workType, phase: options.phase, agentType: options.agentType, difficulty: options.difficulty });
+  if (options.model) {
+    console.log(`[DEBUG] Using explicit model: ${options.model}`);
+    return options.model;
+  }
+  try {
+    if (options.workType) {
+      return getModelId(options.workType);
+    }
+    if (options.phase) {
+      const workType = `issue-agent:${options.phase}`;
+      return getModelId(workType);
+    }
+    if (options.agentType && options.agentType !== "work-agent") {
+      if (options.agentType === "planning-agent") {
+        return getModelId("planning-agent");
+      }
+      const workType = `specialist-${options.agentType}`;
+      return getModelId(workType);
+    }
+    if (options.difficulty) {
+      const settings = loadSettings();
+      if (settings.models.complexity[options.difficulty]) {
+        console.warn(`Using legacy complexity-based routing for ${options.difficulty}. Consider migrating to work types.`);
+        return settings.models.complexity[options.difficulty];
+      }
+    }
+    return "kimi-k2.5";
+  } catch (error) {
+    console.warn("Warning: Could not resolve model using work type router, using default");
+    console.log(`[DEBUG] Catch block, options.model: ${options.model}, fallback: kimi-k2.5`);
+    return options.model || "kimi-k2.5";
+  }
+}
+async function spawnAgent(options) {
+  const agentId = `agent-${options.issueId.toLowerCase()}`;
+  if (sessionExists(agentId)) {
+    throw new Error(`Agent ${agentId} already running. Use 'pan work tell' to message it.`);
+  }
+  initHook(agentId);
+  const selectedModel = determineModel(options);
+  console.log(`[DEBUG] Selected model: ${selectedModel}`);
+  const state = {
+    id: agentId,
+    issueId: options.issueId,
+    workspace: options.workspace,
+    runtime: options.runtime || "claude",
+    model: selectedModel,
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Initialize Phase 4 fields (legacy)
+    complexity: options.difficulty,
+    handoffCount: 0,
+    costSoFar: 0,
+    // Work type system (PAN-118)
+    phase: options.phase,
+    workType: options.workType
+  };
+  saveAgentState(state);
+  let prompt = options.prompt || "";
+  const { hasWork, items } = checkHook(agentId);
+  if (hasWork) {
+    const fixedPointPrompt = generateFixedPointPrompt(agentId);
+    if (fixedPointPrompt) {
+      prompt = fixedPointPrompt + "\n\n---\n\n" + prompt;
+    }
+  }
+  const promptFile = join4(getAgentDir(agentId), "initial-prompt.md");
+  if (prompt) {
+    writeFileSync4(promptFile, prompt);
+  }
+  checkAndSetupHooks();
+  writeTaskCache(agentId, options.issueId);
+  clearReadySignal(agentId);
+  const provider = getProviderForModel(selectedModel);
+  const settings = loadSettings();
+  let providerEnv = {};
+  if (provider.name !== "anthropic") {
+    const apiKey = settings.api_keys[provider.name];
+    if (apiKey) {
+      providerEnv = getProviderEnv(provider, apiKey);
+    } else {
+      console.warn(`Warning: No API key configured for ${provider.displayName}, falling back to Anthropic`);
+    }
+  }
+  let claudeCmd;
+  if (prompt) {
+    const launcherScript = join4(getAgentDir(agentId), "launcher.sh");
+    const launcherContent = `#!/bin/bash
+prompt=$(cat "${promptFile}")
+exec claude --dangerously-skip-permissions --model ${state.model} "$prompt"
+`;
+    writeFileSync4(launcherScript, launcherContent, { mode: 493 });
+    claudeCmd = `bash "${launcherScript}"`;
+  } else {
+    claudeCmd = `claude --dangerously-skip-permissions --model ${state.model}`;
+  }
+  createSession(agentId, options.workspace, claudeCmd, {
+    env: {
+      PANOPTICON_AGENT_ID: agentId,
+      ...providerEnv
+      // Add provider-specific env vars (BASE_URL, AUTH_TOKEN, etc.)
+    }
+  });
+  state.status = "running";
+  saveAgentState(state);
+  startWork(agentId, options.issueId);
+  return state;
+}
+function listRunningAgents() {
+  const tmuxSessions = getAgentSessions();
+  const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
+  const agents = [];
+  if (!existsSync4(AGENTS_DIR)) return agents;
+  const dirs = readdirSync3(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dirs) {
+    const state = getAgentState(dir.name);
+    if (state) {
+      agents.push({
+        ...state,
+        tmuxActive: tmuxNames.has(state.id)
+      });
+    }
+  }
+  return agents;
+}
+function stopAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (sessionExists(normalizedId)) {
+    killSession(normalizedId);
+  }
+  const state = getAgentState(normalizedId);
+  if (state) {
+    state.status = "stopped";
+    saveAgentState(state);
+  }
+}
+async function messageAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const runtimeState = getAgentRuntimeState(normalizedId);
+  if (runtimeState?.state === "suspended") {
+    console.log(`[agents] Auto-resuming suspended agent ${normalizedId} to deliver message`);
+    const result = await resumeAgent(normalizedId, message);
+    if (!result.success) {
+      throw new Error(`Failed to auto-resume agent: ${result.error}`);
+    }
+    return;
+  }
+  if (!sessionExists(normalizedId)) {
+    throw new Error(`Agent ${normalizedId} not running`);
+  }
+  sendKeys(normalizedId, message);
+  const mailDir = join4(getAgentDir(normalizedId), "mail");
+  mkdirSync3(mailDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  writeFileSync4(
+    join4(mailDir, `${timestamp}.md`),
+    `# Message
+
+${message}
+`
+  );
+}
+async function resumeAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const runtimeState = getAgentRuntimeState(normalizedId);
+  if (!runtimeState || runtimeState.state !== "suspended") {
+    return {
+      success: false,
+      error: `Cannot resume agent in state: ${runtimeState?.state || "unknown"}`
+    };
+  }
+  const sessionId = getSessionId(normalizedId);
+  if (!sessionId) {
+    return {
+      success: false,
+      error: "No saved session ID found"
+    };
+  }
+  const agentState = getAgentState(normalizedId);
+  if (!agentState) {
+    return {
+      success: false,
+      error: "Agent state not found"
+    };
+  }
+  if (sessionExists(normalizedId)) {
+    return {
+      success: false,
+      error: "Agent session already exists"
+    };
+  }
+  try {
+    clearReadySignal(normalizedId);
+    const claudeCmd = `claude --resume "${sessionId}" --dangerously-skip-permissions`;
+    createSession(normalizedId, agentState.workspace, claudeCmd, {
+      env: {
+        PANOPTICON_AGENT_ID: normalizedId
+      }
+    });
+    if (message) {
+      const ready = await waitForReadySignal(normalizedId, 30);
+      if (ready) {
+        sendKeys(normalizedId, message);
+      } else {
+        console.error("Claude SessionStart hook did not fire during resume, message not sent");
+      }
+    }
+    saveAgentRuntimeState(normalizedId, {
+      state: "active",
+      resumedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (agentState) {
+      agentState.status = "running";
+      agentState.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      saveAgentState(agentState);
+    }
+    return { success: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to resume agent: ${msg}`
+    };
+  }
+}
+function detectCrashedAgents() {
+  const agents = listRunningAgents();
+  return agents.filter(
+    (agent) => agent.status === "running" && !agent.tmuxActive
+  );
+}
+function recoverAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const state = getAgentState(normalizedId);
+  if (!state) {
+    return null;
+  }
+  if (sessionExists(normalizedId)) {
+    return state;
+  }
+  const healthFile = join4(getAgentDir(normalizedId), "health.json");
+  let health = { consecutiveFailures: 0, killCount: 0, recoveryCount: 0 };
+  if (existsSync4(healthFile)) {
+    try {
+      health = { ...health, ...JSON.parse(readFileSync4(healthFile, "utf-8")) };
+    } catch {
+    }
+  }
+  health.recoveryCount = (health.recoveryCount || 0) + 1;
+  writeFileSync4(healthFile, JSON.stringify(health, null, 2));
+  const recoveryPrompt = generateRecoveryPrompt(state);
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  createSession(normalizedId, state.workspace, claudeCmd);
+  state.status = "running";
+  state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  saveAgentState(state);
+  return state;
+}
+function generateRecoveryPrompt(state) {
+  const lines = [
+    "# Agent Recovery",
+    "",
+    "\u26A0\uFE0F This agent session was recovered after a crash.",
+    "",
+    "## Previous Context",
+    `- Issue: ${state.issueId}`,
+    `- Workspace: ${state.workspace}`,
+    `- Started: ${state.startedAt}`,
+    "",
+    "## Recovery Steps",
+    "1. Check beads for context: `bd show " + state.issueId + "`",
+    "2. Review recent git commits: `git log --oneline -10`",
+    "3. Check hook for pending work: `pan work hook check`",
+    "4. Resume from last known state",
+    "",
+    "## FPP Reminder",
+    '> "Any runnable action is a fixed point and must resolve before the system can rest."',
+    ""
+  ];
+  const { hasWork } = checkHook(state.id);
+  if (hasWork) {
+    const fixedPointPrompt = generateFixedPointPrompt(state.id);
+    if (fixedPointPrompt) {
+      lines.push("---");
+      lines.push("");
+      lines.push(fixedPointPrompt);
+    }
+  }
+  return lines.join("\n");
+}
+function autoRecoverAgents() {
+  const crashed = detectCrashedAgents();
+  const recovered = [];
+  const failed = [];
+  for (const agent of crashed) {
+    try {
+      const result = recoverAgent(agent.id);
+      if (result) {
+        recovered.push(agent.id);
+      } else {
+        failed.push(agent.id);
+      }
+    } catch (error) {
+      failed.push(agent.id);
+    }
+  }
+  return { recovered, failed };
+}
+function checkAndSetupHooks() {
+  const settingsPath = join4(homedir2(), ".claude", "settings.json");
+  const hookPath = join4(homedir2(), ".panopticon", "bin", "heartbeat-hook");
+  if (existsSync4(settingsPath)) {
+    try {
+      const settingsContent = readFileSync4(settingsPath, "utf-8");
+      const settings = JSON.parse(settingsContent);
+      const postToolUse = settings?.hooks?.PostToolUse || [];
+      const hookConfigured = postToolUse.some(
+        (hookConfig) => hookConfig.hooks?.some(
+          (hook) => hook.command === hookPath || hook.command?.includes("panopticon") || hook.command?.includes("heartbeat-hook")
+        )
+      );
+      if (hookConfigured) {
+        return;
+      }
+    } catch {
+    }
+  }
+  try {
+    console.log("Configuring Panopticon heartbeat hooks...");
+    exec("pan setup hooks", (error) => {
+      if (error) {
+        console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
+      } else {
+        console.log("\u2713 Heartbeat hooks configured");
+      }
+    });
+  } catch (error) {
+    console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
+  }
+}
+function writeTaskCache(agentId, issueId) {
+  const cacheDir = join4(getAgentDir(agentId));
+  mkdirSync3(cacheDir, { recursive: true });
+  const cacheFile = join4(cacheDir, "current-task.json");
+  writeFileSync4(
+    cacheFile,
+    JSON.stringify({
+      id: issueId,
+      title: `Working on ${issueId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2)
+  );
+}
+
+export {
+  sessionExists,
+  createSession,
+  killSession,
+  sendKeys,
+  pushToHook,
+  checkHook,
+  popFromHook,
+  clearHook,
+  sendMail,
+  generateFixedPointPrompt,
+  getAgentCV,
+  getAgentRankings,
+  formatCV,
+  getModelId,
+  getAgentDir,
+  getAgentState,
+  saveAgentState,
+  getAgentRuntimeState,
+  saveAgentRuntimeState,
+  appendActivity,
+  getActivity,
+  saveSessionId,
+  getSessionId,
+  spawnAgent,
+  listRunningAgents,
+  stopAgent,
+  messageAgent,
+  resumeAgent,
+  detectCrashedAgents,
+  recoverAgent,
+  autoRecoverAgents
+};
+//# sourceMappingURL=chunk-H45CLB7E.js.map