panopticon-cli 0.4.5 → 0.4.6

package/dist/chunk-PUR532O7.js

@@ -0,0 +1,1556 @@
+import {
+  AGENTS_DIR,
+  PANOPTICON_HOME,
+  init_paths
+} from "./chunk-KGPRXDMX.js";
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/tmux.ts
+import { execSync } from "child_process";
+import { writeFileSync, chmodSync, appendFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function ensureLogDir() {
+  const logDir = join(PANOPTICON_HOME, "logs");
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+function logSendKeys(sessionName, keys, caller) {
+  try {
+    ensureLogDir();
+    const stack = new Error().stack || "";
+    const stackLines = stack.split("\n").slice(3, 6);
+    const callerInfo = caller || stackLines.map((l) => l.trim()).join(" <- ");
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionName,
+      keysLength: keys.length,
+      keysPreview: keys.length > 200 ? keys.slice(0, 200) + "..." : keys,
+      caller: callerInfo,
+      pid: process.pid
+    };
+    appendFileSync(SENDKEYS_LOG_FILE, JSON.stringify(entry) + "\n", "utf-8");
+  } catch {
+  }
+}
+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, caller) {
+  logSendKeys(sessionName, keys, caller);
+  const escapedKeys = keys.replace(/"/g, '\\"');
+  execSync(`tmux send-keys -t ${sessionName} "${escapedKeys}"`);
+  execSync(`tmux send-keys -t ${sessionName} C-m`);
+}
+function capturePane(sessionName, lines = 50) {
+  try {
+    return execSync(`tmux capture-pane -t ${sessionName} -p -S -${lines}`, {
+      encoding: "utf8"
+    });
+  } catch {
+    return "";
+  }
+}
+function getAgentSessions() {
+  return listSessions().filter((s) => s.name.startsWith("agent-"));
+}
+var SENDKEYS_LOG_FILE;
+var init_tmux = __esm({
+  "src/lib/tmux.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    SENDKEYS_LOG_FILE = join(PANOPTICON_HOME, "logs", "sendkeys.jsonl");
+  }
+});
+
+// src/lib/hooks.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2, readdirSync, unlinkSync } from "fs";
+import { join as join2 } from "path";
+function getHookDir(agentId) {
+  return join2(AGENTS_DIR, agentId);
+}
+function getHookFile(agentId) {
+  return join2(getHookDir(agentId), "hook.json");
+}
+function getMailDir(agentId) {
+  return join2(getHookDir(agentId), "mail");
+}
+function initHook(agentId) {
+  const hookDir = getHookDir(agentId);
+  const mailDir = getMailDir(agentId);
+  mkdirSync2(hookDir, { recursive: true });
+  mkdirSync2(mailDir, { recursive: true });
+  const hookFile = getHookFile(agentId);
+  if (!existsSync2(hookFile)) {
+    const hook = {
+      agentId,
+      items: []
+    };
+    writeFileSync2(hookFile, JSON.stringify(hook, null, 2));
+  }
+}
+function getHook(agentId) {
+  const hookFile = getHookFile(agentId);
+  if (!existsSync2(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 (existsSync2(mailDir)) {
+      const mails = readdirSync(mailDir).filter((f) => f.endsWith(".json"));
+      if (mails.length > 0) {
+        const mailItems = mails.map((file) => {
+          try {
+            const content = readFileSync(join2(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(
+    join2(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");
+}
+var init_hooks = __esm({
+  "src/lib/hooks.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+  }
+});
+
+// src/lib/work-types.ts
+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(", ")}`
+    );
+  }
+}
+var WORK_TYPES;
+var init_work_types = __esm({
+  "src/lib/work-types.ts"() {
+    "use strict";
+    init_esm_shims();
+    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"
+      }
+    };
+  }
+});
+
+// src/lib/model-fallback.ts
+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;
+}
+var MODEL_PROVIDERS, FALLBACK_MAP, DEFAULT_FALLBACK;
+var init_model_fallback = __esm({
+  "src/lib/model-fallback.ts"() {
+    "use strict";
+    init_esm_shims();
+    MODEL_PROVIDERS = {
+      // Anthropic models
+      "claude-opus-4-6": "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"
+    };
+    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
+    };
+    DEFAULT_FALLBACK = "claude-sonnet-4-5";
+  }
+});
+
+// src/lib/config-yaml.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import yaml from "js-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 = readFileSync2(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 mergeShadowConfig(result, config) {
+  if (!config?.shadow) return;
+  if (config.shadow.enabled !== void 0) {
+    result.enabled = config.shadow.enabled;
+  }
+  if (config.shadow.trackers) {
+    if (config.shadow.trackers.linear !== void 0) {
+      result.trackers.linear = config.shadow.trackers.linear;
+    }
+    if (config.shadow.trackers.github !== void 0) {
+      result.trackers.github = config.shadow.trackers.github;
+    }
+    if (config.shadow.trackers.gitlab !== void 0) {
+      result.trackers.gitlab = config.shadow.trackers.gitlab;
+    }
+    if (config.shadow.trackers.rally !== void 0) {
+      result.trackers.rally = config.shadow.trackers.rally;
+    }
+  }
+}
+function mergeConfigs(...configs) {
+  const result = {
+    ...DEFAULT_CONFIG,
+    enabledProviders: new Set(DEFAULT_CONFIG.enabledProviders),
+    shadow: {
+      enabled: DEFAULT_CONFIG.shadow.enabled,
+      trackers: { ...DEFAULT_CONFIG.shadow.trackers }
+    }
+  };
+  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;
+    }
+    mergeShadowConfig(result.shadow, config);
+  }
+  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");
+  }
+  if (process.env.SHADOW_MODE !== void 0) {
+    const envShadowMode = ["true", "1", "yes"].includes(process.env.SHADOW_MODE.toLowerCase());
+    config.shadow.enabled = envShadowMode;
+  }
+  return config;
+}
+var DEFAULT_CONFIG, GLOBAL_CONFIG_PATH;
+var init_config_yaml = __esm({
+  "src/lib/config-yaml.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_CONFIG = {
+      enabledProviders: /* @__PURE__ */ new Set(["anthropic"]),
+      // Only Anthropic by default
+      apiKeys: {},
+      overrides: {},
+      geminiThinkingLevel: 3,
+      shadow: {
+        enabled: false,
+        trackers: {
+          linear: false,
+          github: false,
+          gitlab: false,
+          rally: false
+        }
+      }
+    };
+    GLOBAL_CONFIG_PATH = join3(homedir(), ".panopticon", "config.yaml");
+  }
+});
+
+// src/lib/model-capabilities.ts
+function getModelCapability(model) {
+  return MODEL_CAPABILITIES[model];
+}
+var MODEL_CAPABILITIES;
+var init_model_capabilities = __esm({
+  "src/lib/model-capabilities.ts"() {
+    "use strict";
+    init_esm_shims();
+    MODEL_CAPABILITIES = {
+      // ═══════════════════════════════════════════════════════════════════════════
+      // ANTHROPIC MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "claude-opus-4-6": {
+        model: "claude-opus-4-6",
+        provider: "anthropic",
+        displayName: "Claude Opus 4.6",
+        costPer1MTokens: 45,
+        // $5 in / $25 out → same pricing as 4.5
+        contextWindow: 2e5,
+        // 1M available via opt-in beta, but we use 200K
+        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.6 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: "Successor to Opus 4.5. Same pricing, 1M context available (opt-in beta). Best for planning, security, complex reasoning."
+      },
+      "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."
+      }
+    };
+  }
+});
+
+// src/lib/smart-model-selector.ts
+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
+    }))
+  };
+}
+var WORK_TYPE_REQUIREMENTS;
+var init_smart_model_selector = __esm({
+  "src/lib/smart-model-selector.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_model_capabilities();
+    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
+      ]
+    };
+  }
+});
+
+// src/lib/work-type-router.ts
+function getGlobalRouter() {
+  if (!globalRouter) {
+    globalRouter = new WorkTypeRouter();
+  }
+  return globalRouter;
+}
+function getModelId(workTypeId) {
+  return getGlobalRouter().getModelId(workTypeId);
+}
+var WorkTypeRouter, globalRouter;
+var init_work_type_router = __esm({
+  "src/lib/work-type-router.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_work_types();
+    init_model_fallback();
+    init_config_yaml();
+    init_smart_model_selector();
+    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
+          }
+        };
+      }
+    };
+    globalRouter = null;
+  }
+});
+
+export {
+  sessionExists,
+  createSession,
+  killSession,
+  sendKeys,
+  capturePane,
+  getAgentSessions,
+  init_tmux,
+  initHook,
+  pushToHook,
+  checkHook,
+  popFromHook,
+  clearHook,
+  sendMail,
+  generateFixedPointPrompt,
+  init_hooks,
+  loadConfig,
+  init_config_yaml,
+  getModelId,
+  init_work_type_router
+};
+//# sourceMappingURL=chunk-PUR532O7.js.map