@ngandu/ulicode 0.0.6

package/dist/chunk-PUVEPQQ3.cjs

@@ -0,0 +1,1805 @@
+'use strict';
+
+var chunkIEV2IT3O_cjs = require('./chunk-IEV2IT3O.cjs');
+var chunkR6JK3DE3_cjs = require('./chunk-R6JK3DE3.cjs');
+var fs2 = require('fs');
+var os = require('os');
+var path4 = require('path');
+var url = require('url');
+var harness = require('@mastra/core/harness');
+var yaml = require('js-yaml');
+var node_js = require('vscode-jsonrpc/node.js');
+var vscodeLanguageserverProtocol = require('vscode-languageserver-protocol');
+var child_process = require('child_process');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
+var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
+
+var MODE_INDICATOR_FIELDS = /* @__PURE__ */ new Set([
+  "subagents",
+  "default",
+  "defaultModelId",
+  "color"
+]);
+function idFromFilename(filePath) {
+  return path4.basename(filePath).replace(/\.agent\.md$/i, "");
+}
+function descriptionFromBody(body) {
+  const lines = body.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const sentence = trimmed.match(/^[^.!?]+[.!?]?/)?.[0] ?? trimmed;
+    return sentence.length > 120 ? sentence.slice(0, 117) + "..." : sentence;
+  }
+  return "";
+}
+function inferKind(frontmatter) {
+  for (const key of Object.keys(frontmatter)) {
+    if (MODE_INDICATOR_FIELDS.has(key)) return "mode";
+  }
+  return "subagent";
+}
+var BUILTIN_DEFINITIONS_DIR = path4.join(path4.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-PUVEPQQ3.cjs', document.baseURI).href)))), "definitions");
+var GLOBAL_AGENT_LOCATIONS = [
+  ".claude/agents",
+  ".ulicode/agents",
+  ".uli-cli/agents",
+  ".pulse/agents",
+  ".mastracode/agents",
+  ".config/claude/agents",
+  ".config/ulicode/agents",
+  ".config/uli-cli/agents",
+  ".config/pulse/agents",
+  ".config/mastracode/agents"
+];
+var PROJECT_AGENT_LOCATIONS = [
+  ".claude/agents",
+  ".ulicode/agents",
+  ".uli-cli/agents",
+  ".pulse/agents",
+  ".mastracode/agents"
+];
+var WORKSPACE_TOOL_IDS = new Set(Object.values(chunkR6JK3DE3_cjs.MC_TOOLS));
+var DIRECT_SUBAGENT_TOOLS = {
+  task_write: harness.taskWriteTool,
+  task_check: harness.taskCheckTool
+};
+var agentDefinitionCache = /* @__PURE__ */ new Map();
+function pushDiagnostic(diagnostics, severity, scope, sourcePath, message) {
+  diagnostics.push({ severity, scope, sourcePath, message });
+}
+function titleCaseId(id) {
+  return id.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function parseFrontmatter(content) {
+  const normalized = content.replace(/^\uFEFF/, "");
+  const match = normalized.match(/^---\r?\n([\s\S]*?)(?:\r?\n)?---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    return null;
+  }
+  const frontmatter = yaml__namespace.load(match[1]) ?? {};
+  return { frontmatter, body: match[2].trim() };
+}
+function scanAgentDirectory(dirPath) {
+  if (!fs2.existsSync(dirPath)) {
+    return [];
+  }
+  const results = [];
+  for (const entry of fs2.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = path4.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...scanAgentDirectory(fullPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".agent.md")) {
+      results.push(fullPath);
+    }
+  }
+  return results.sort((left, right) => left.localeCompare(right));
+}
+function normalizeModeDefinition(filePath, scope, frontmatter, instructions, diagnostics) {
+  const id = (frontmatter.id ?? idFromFilename(filePath)).trim();
+  if (!id) {
+    pushDiagnostic(diagnostics, "error", scope, filePath, "could not derive `id` for mode definition");
+    return null;
+  }
+  const name = typeof frontmatter.name === "string" && frontmatter.name.trim() ? frontmatter.name.trim() : titleCaseId(id);
+  const description = typeof frontmatter.description === "string" && frontmatter.description.trim() ? frontmatter.description.trim() : descriptionFromBody(instructions);
+  if (frontmatter.subagents !== void 0 && !Array.isArray(frontmatter.subagents)) {
+    pushDiagnostic(diagnostics, "error", scope, filePath, `mode \`${id}\` must declare \`subagents\` as an array`);
+    return null;
+  }
+  if (Array.isArray(frontmatter.subagents) && frontmatter.subagents.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+    pushDiagnostic(
+      diagnostics,
+      "error",
+      scope,
+      filePath,
+      `mode \`${id}\` has invalid \`subagents\` entries; expected non-empty string ids`
+    );
+    return null;
+  }
+  const subagents = Array.isArray(frontmatter.subagents) ? frontmatter.subagents.map((entry) => entry.trim()) : [];
+  return {
+    id,
+    name,
+    kind: "mode",
+    description,
+    instructions,
+    sourcePath: filePath,
+    scope,
+    hidden: frontmatter.hidden === true,
+    default: frontmatter.default === true,
+    defaultModelId: typeof frontmatter.defaultModelId === "string" ? frontmatter.defaultModelId.trim() : void 0,
+    color: typeof frontmatter.color === "string" ? frontmatter.color.trim() : void 0,
+    subagents
+  };
+}
+function normalizeSubagentDefinition(filePath, scope, frontmatter, instructions, diagnostics) {
+  const id = (frontmatter.id ?? idFromFilename(filePath)).trim();
+  if (!id) {
+    pushDiagnostic(diagnostics, "error", scope, filePath, "could not derive `id` for subagent definition");
+    return null;
+  }
+  const name = typeof frontmatter.name === "string" && frontmatter.name.trim() ? frontmatter.name.trim() : titleCaseId(id);
+  const description = typeof frontmatter.description === "string" && frontmatter.description.trim() ? frontmatter.description.trim() : descriptionFromBody(instructions);
+  if (frontmatter.allowedWorkspaceTools && frontmatter.workspaceTools) {
+    pushDiagnostic(
+      diagnostics,
+      "error",
+      scope,
+      filePath,
+      `subagent \`${id}\` cannot declare both \`allowedWorkspaceTools\` and \`workspaceTools\``
+    );
+    return null;
+  }
+  if (frontmatter.tools && typeof frontmatter.tools !== "string" && (!Array.isArray(frontmatter.tools) || frontmatter.tools.some((entry) => typeof entry !== "string"))) {
+    pushDiagnostic(diagnostics, "error", scope, filePath, `subagent \`${id}\` must declare \`tools\` as an array of strings or "all"`);
+    return null;
+  }
+  const useAllTools = frontmatter.tools === "all" || Array.isArray(frontmatter.tools) && frontmatter.tools.length === 1 && frontmatter.tools[0] === "all";
+  const tools = useAllTools ? Object.keys(DIRECT_SUBAGENT_TOOLS) : Array.isArray(frontmatter.tools) ? frontmatter.tools.map((entry) => entry.trim()) : [];
+  const rawWorkspaceTools = frontmatter.allowedWorkspaceTools ?? frontmatter.workspaceTools;
+  const useAllWorkspaceTools = rawWorkspaceTools === "all" || Array.isArray(rawWorkspaceTools) && rawWorkspaceTools.length === 1 && rawWorkspaceTools[0] === "all";
+  let allowedWorkspaceTools;
+  if (useAllWorkspaceTools) {
+    allowedWorkspaceTools = void 0;
+  } else if (Array.isArray(rawWorkspaceTools)) {
+    allowedWorkspaceTools = rawWorkspaceTools.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    );
+  } else if (typeof rawWorkspaceTools === "string") {
+    pushDiagnostic(diagnostics, "warning", scope, filePath, `subagent \`${id}\` has unrecognized \`allowedWorkspaceTools\` value "${rawWorkspaceTools}"; expected array or "all"`);
+    allowedWorkspaceTools = void 0;
+  } else {
+    allowedWorkspaceTools = void 0;
+  }
+  const unknownDirectTools = tools.filter((toolId) => !(toolId in DIRECT_SUBAGENT_TOOLS));
+  if (unknownDirectTools.length > 0) {
+    pushDiagnostic(diagnostics, "warning", scope, filePath, `subagent \`${id}\` declares unknown direct tools (ignored at runtime): ${unknownDirectTools.join(", ")}`);
+  }
+  const unknownWorkspaceTools = (allowedWorkspaceTools ?? []).filter((toolId) => !WORKSPACE_TOOL_IDS.has(toolId));
+  if (unknownWorkspaceTools.length > 0) {
+    pushDiagnostic(diagnostics, "warning", scope, filePath, `subagent \`${id}\` declares unknown workspace tools (ignored at runtime): ${unknownWorkspaceTools.join(", ")}`);
+  }
+  return {
+    id,
+    name,
+    kind: "subagent",
+    description,
+    instructions,
+    sourcePath: filePath,
+    scope,
+    hidden: frontmatter.hidden === true,
+    tools,
+    allowedWorkspaceTools,
+    defaultModelFromMode: typeof frontmatter.defaultModelFromMode === "string" ? frontmatter.defaultModelFromMode.trim() : typeof frontmatter.modeId === "string" ? frontmatter.modeId.trim() : void 0
+  };
+}
+function parseAgentDefinitionFile(filePath, scope, diagnostics) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const parsed = parseFrontmatter(content);
+    if (!parsed) {
+      pushDiagnostic(diagnostics, "error", scope, filePath, "missing valid YAML frontmatter");
+      return null;
+    }
+    const instructions = parsed.body.trim();
+    if (!instructions) {
+      pushDiagnostic(diagnostics, "error", scope, filePath, "missing markdown instruction body");
+      return null;
+    }
+    const kind = parsed.frontmatter.kind ?? inferKind(parsed.frontmatter);
+    if (kind === "mode") {
+      return normalizeModeDefinition(filePath, scope, parsed.frontmatter, instructions, diagnostics);
+    }
+    if (kind === "subagent") {
+      return normalizeSubagentDefinition(filePath, scope, parsed.frontmatter, instructions, diagnostics);
+    }
+    pushDiagnostic(diagnostics, "error", scope, filePath, `unsupported \`kind\`: ${String(parsed.frontmatter.kind)}; expected \`mode\` or \`subagent\``);
+    return null;
+  } catch (error) {
+    pushDiagnostic(
+      diagnostics,
+      "error",
+      scope,
+      filePath,
+      `failed to parse agent definition: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function validateRegistry(registry, diagnostics) {
+  const modeIds = new Set(registry.modes.map((mode) => mode.id));
+  const subagentIds = new Set(registry.subagents.map((subagent) => subagent.id));
+  for (const mode of registry.modes) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const subagentId of mode.subagents) {
+      if (seen.has(subagentId)) {
+        pushDiagnostic(diagnostics, "warning", mode.scope, mode.sourcePath, `mode \`${mode.id}\` lists duplicate subagent \`${subagentId}\``);
+        continue;
+      }
+      seen.add(subagentId);
+      if (!subagentIds.has(subagentId)) {
+        pushDiagnostic(
+          diagnostics,
+          "error",
+          mode.scope,
+          mode.sourcePath,
+          `mode \`${mode.id}\` references unknown subagent \`${subagentId}\` in \`subagents\``
+        );
+      }
+    }
+  }
+  for (const subagent of registry.subagents) {
+    if (subagent.defaultModelFromMode && !modeIds.has(subagent.defaultModelFromMode)) {
+      pushDiagnostic(
+        diagnostics,
+        "error",
+        subagent.scope,
+        subagent.sourcePath,
+        `subagent \`${subagent.id}\` references unknown mode \`${subagent.defaultModelFromMode}\` in \`defaultModelFromMode\``
+      );
+    }
+    const ownerCount = registry.modes.filter((mode) => mode.subagents.includes(subagent.id)).length;
+    if (ownerCount === 0) {
+      pushDiagnostic(
+        diagnostics,
+        "warning",
+        subagent.scope,
+        subagent.sourcePath,
+        `subagent \`${subagent.id}\` is not referenced by any top-level mode \`subagents\` list`
+      );
+    }
+  }
+  const defaultModes = registry.modes.filter((mode) => mode.default);
+  if (defaultModes.length === 0) {
+    pushDiagnostic(diagnostics, "warning", "builtin", BUILTIN_DEFINITIONS_DIR, "no default top-level mode is defined");
+  } else if (defaultModes.length > 1) {
+    pushDiagnostic(
+      diagnostics,
+      "error",
+      "builtin",
+      BUILTIN_DEFINITIONS_DIR,
+      `multiple default top-level modes found: ${defaultModes.map((mode) => mode.id).join(", ")}`
+    );
+  }
+}
+function mergeDefinitions(entries) {
+  const modeMap = /* @__PURE__ */ new Map();
+  const subagentMap = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const subagentModeClaims = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const filePath of scanAgentDirectory(entry.dirPath)) {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      const parsed = parseFrontmatter(content);
+      const rawModes = parsed?.frontmatter?.modes;
+      const definition = parseAgentDefinitionFile(filePath, entry.scope, diagnostics);
+      if (!definition) {
+        continue;
+      }
+      if (definition.kind === "mode") {
+        modeMap.set(definition.id, definition);
+      } else {
+        subagentMap.set(definition.id, definition);
+        if (Array.isArray(rawModes) && rawModes.length > 0) {
+          subagentModeClaims.set(
+            definition.id,
+            rawModes.filter((m) => typeof m === "string" && m.trim().length > 0).map((m) => m.trim())
+          );
+        }
+      }
+    }
+  }
+  for (const [subagentId, claimedModeIds] of subagentModeClaims) {
+    for (const modeId of claimedModeIds) {
+      const mode = modeMap.get(modeId);
+      if (mode && !mode.subagents.includes(subagentId)) {
+        mode.subagents.push(subagentId);
+      }
+    }
+  }
+  const defaultMode = Array.from(modeMap.values()).find((m) => m.default);
+  if (defaultMode) {
+    for (const [subagentId] of subagentMap) {
+      if (subagentModeClaims.has(subagentId)) continue;
+      const isReferenced = Array.from(modeMap.values()).some((m) => m.subagents.includes(subagentId));
+      if (!isReferenced) {
+        defaultMode.subagents.push(subagentId);
+      }
+    }
+  }
+  const registry = {
+    modes: Array.from(modeMap.values()),
+    subagents: Array.from(subagentMap.values()),
+    diagnostics
+  };
+  validateRegistry(registry, diagnostics);
+  return registry;
+}
+function loadAgentDefinitions(projectPath) {
+  const entries = [{ dirPath: BUILTIN_DEFINITIONS_DIR, scope: "builtin" }];
+  const home = os.homedir();
+  for (const location of GLOBAL_AGENT_LOCATIONS) {
+    entries.push({ dirPath: path4.join(home, location), scope: "user" });
+  }
+  for (const location of PROJECT_AGENT_LOCATIONS) {
+    entries.push({ dirPath: path4.join(projectPath, location), scope: "project" });
+  }
+  return mergeDefinitions(entries);
+}
+function loadAgentDefinitionsCached(projectPath) {
+  const cached = agentDefinitionCache.get(projectPath);
+  if (cached) {
+    return {
+      modes: cached.modes.map((mode) => ({ ...mode, subagents: [...mode.subagents] })),
+      subagents: cached.subagents.map((subagent) => ({
+        ...subagent,
+        tools: [...subagent.tools],
+        allowedWorkspaceTools: subagent.allowedWorkspaceTools ? [...subagent.allowedWorkspaceTools] : void 0
+      })),
+      diagnostics: cached.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+    };
+  }
+  const loaded = loadAgentDefinitions(projectPath);
+  agentDefinitionCache.set(projectPath, loaded);
+  return loadAgentDefinitionsCached(projectPath);
+}
+function getModeDefinition(projectPath, modeId) {
+  return loadAgentDefinitionsCached(projectPath).modes.find((mode) => mode.id === modeId);
+}
+function formatAgentDefinitionDiagnostics(diagnostics, maxItems = 5) {
+  if (diagnostics.length === 0) {
+    return null;
+  }
+  const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+  const headlineParts = [];
+  if (errors.length > 0) {
+    headlineParts.push(`${errors.length} error${errors.length === 1 ? "" : "s"}`);
+  }
+  if (warnings.length > 0) {
+    headlineParts.push(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}`);
+  }
+  const visible = diagnostics.slice(0, maxItems);
+  const lines = visible.map((diagnostic) => {
+    const prefix = diagnostic.severity === "error" ? "error" : "warning";
+    return `- ${prefix}: ${diagnostic.sourcePath} \u2014 ${diagnostic.message}`;
+  });
+  if (diagnostics.length > maxItems) {
+    lines.push(`- ... ${diagnostics.length - maxItems} more`);
+  }
+  return `Ignored invalid custom agent definitions (${headlineParts.join(", ")}):
+${lines.join("\n")}`;
+}
+function getSubagentOwnerModes(registry, subagentId) {
+  return registry.modes.filter((mode) => mode.subagents.includes(subagentId));
+}
+function getAllowedSubagentIdsForMode(registry, modeId) {
+  return registry.modes.find((mode) => mode.id === modeId)?.subagents ?? [];
+}
+function getSubagentModeMap(registry) {
+  const mapping = {};
+  for (const subagent of registry.subagents) {
+    if (subagent.defaultModelFromMode) {
+      mapping[subagent.id] = subagent.defaultModelFromMode;
+      continue;
+    }
+    const ownerMode = registry.modes.find((mode) => mode.subagents.includes(subagent.id));
+    if (ownerMode) {
+      mapping[subagent.id] = ownerMode.id;
+    }
+  }
+  return mapping;
+}
+function createHarnessModesFromDefinitions(registry, codeAgent) {
+  return registry.modes.map((mode) => ({
+    id: mode.id,
+    name: mode.name,
+    default: mode.default,
+    defaultModelId: mode.defaultModelId,
+    color: mode.color,
+    agent: codeAgent
+  }));
+}
+function createHarnessSubagentsFromDefinitions(registry, disabledTools) {
+  return registry.subagents.map((subagent) => {
+    const directTools = Object.fromEntries(
+      subagent.tools.filter((toolId) => !disabledTools?.includes(toolId) && toolId in DIRECT_SUBAGENT_TOOLS).map((toolId) => [toolId, DIRECT_SUBAGENT_TOOLS[toolId]])
+    );
+    const allowedWorkspaceTools = subagent.allowedWorkspaceTools?.filter((toolId) => !disabledTools?.includes(toolId));
+    return {
+      id: subagent.id,
+      name: subagent.name,
+      description: subagent.description,
+      instructions: subagent.instructions,
+      defaultModelId: void 0,
+      allowedWorkspaceTools,
+      ...Object.keys(directTools).length > 0 ? { tools: directTools } : {}
+    };
+  });
+}
+var MAX_LOG_SIZE = 5 * 1024 * 1024;
+var KEEP_SIZE = 4 * 1024 * 1024;
+function formatLogArg(a) {
+  if (typeof a === "string") return a;
+  if (a instanceof Error) return a.stack ?? `${a.name}: ${a.message}`;
+  try {
+    return JSON.stringify(a);
+  } catch {
+    return String(a);
+  }
+}
+function getDebugLogFile() {
+  return path4__namespace.join(chunkIEV2IT3O_cjs.getAppDataDir(), "debug.log");
+}
+function appendDebugLogLine(level, message) {
+  const logFile = getDebugLogFile();
+  const logDir = path4__namespace.dirname(logFile);
+  if (!fs2__namespace.existsSync(logDir)) {
+    fs2__namespace.mkdirSync(logDir, { recursive: true });
+  }
+  truncateLogFile(logFile);
+  fs2__namespace.appendFileSync(logFile, `[${level}] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`);
+}
+function truncateLogFile(logFile) {
+  try {
+    const stat = fs2__namespace.statSync(logFile);
+    if (stat.size > MAX_LOG_SIZE) {
+      const buf = Buffer.alloc(KEEP_SIZE);
+      const fd = fs2__namespace.openSync(logFile, "r");
+      fs2__namespace.readSync(fd, buf, 0, KEEP_SIZE, stat.size - KEEP_SIZE);
+      fs2__namespace.closeSync(fd);
+      const firstNewline = buf.indexOf(10);
+      const trimmed = firstNewline >= 0 ? buf.subarray(firstNewline + 1) : buf;
+      fs2__namespace.writeFileSync(logFile, trimmed);
+    }
+  } catch {
+  }
+}
+function setupDebugLogging() {
+  const debugEnabled = ["true", "1"].includes(process.env.MASTRA_DEBUG ?? "");
+  if (debugEnabled) {
+    const logFile = getDebugLogFile();
+    truncateLogFile(logFile);
+    const logStream = fs2__namespace.createWriteStream(logFile, { flags: "a" });
+    console.error = (...args) => {
+      logStream.write(`[ERROR] ${(/* @__PURE__ */ new Date()).toISOString()} ${args.map(formatLogArg).join(" ")}
+`);
+    };
+    console.warn = (...args) => {
+      logStream.write(`[WARN] ${(/* @__PURE__ */ new Date()).toISOString()} ${args.map(formatLogArg).join(" ")}
+`);
+    };
+  } else {
+    const noop = () => {
+    };
+    console.error = noop;
+    console.warn = noop;
+  }
+}
+function logRuntimeProfile(event, durationMs, details) {
+  const profileEnabled = ["true", "1"].includes(process.env.MASTRA_PROFILE ?? "");
+  if (!profileEnabled) return;
+  const payload = details ? `${event} durationMs=${durationMs.toFixed(2)} ${formatLogArg(details)}` : `${event} durationMs=${durationMs.toFixed(2)}`;
+  appendDebugLogLine("PROFILE", payload);
+}
+var STORAGE_DEFAULTS = {
+  backend: "libsql",
+  libsql: {},
+  pg: {}
+};
+var DEFAULTS = {
+  onboarding: {
+    completedAt: null,
+    skippedAt: null,
+    version: 0,
+    modePackId: null,
+    omPackId: null,
+    claudeMaxOAuthWarningAcknowledgedAt: null
+  },
+  models: {
+    activeModelPackId: null,
+    modeDefaults: {},
+    activeOmPackId: null,
+    omModelOverride: null,
+    subagentModels: {}
+  },
+  preferences: {
+    yolo: null,
+    theme: "auto",
+    thinkingLevel: "off",
+    quietMode: false
+  },
+  storage: { ...STORAGE_DEFAULTS },
+  customModelPacks: [],
+  customProviders: [],
+  modelUseCounts: {},
+  updateDismissedVersion: null,
+  lsp: {}
+};
+var THINKING_LEVEL_VALUES = ["off", "low", "medium", "high", "xhigh"];
+var settingsCache = /* @__PURE__ */ new Map();
+function cloneSettings(settings) {
+  return structuredClone(settings);
+}
+function parseThinkingLevel(value) {
+  return typeof value === "string" && THINKING_LEVEL_VALUES.includes(value) ? value : DEFAULTS.preferences.thinkingLevel;
+}
+function parsePreferences(rawPreferences) {
+  const raw = rawPreferences && typeof rawPreferences === "object" ? rawPreferences : {};
+  return {
+    ...DEFAULTS.preferences,
+    ...raw,
+    thinkingLevel: parseThinkingLevel(raw.thinkingLevel)
+  };
+}
+function getSettingsPath() {
+  return path4.join(chunkIEV2IT3O_cjs.getAppDataDir(), "settings.json");
+}
+function getCustomProviderId(name) {
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "provider";
+}
+function toCustomProviderModelId(providerName, modelName) {
+  const providerId = getCustomProviderId(providerName);
+  const trimmedModelName = modelName.trim();
+  const providerPrefix = `${providerId}/`;
+  if (trimmedModelName.startsWith(providerPrefix)) {
+    return trimmedModelName;
+  }
+  return `${providerId}/${trimmedModelName}`;
+}
+function parseCustomProviders(rawProviders) {
+  if (!Array.isArray(rawProviders)) return [];
+  const parsedProviders = [];
+  for (const rawProvider of rawProviders) {
+    if (!rawProvider || typeof rawProvider !== "object") continue;
+    const candidate = rawProvider;
+    const name = typeof candidate.name === "string" ? candidate.name.trim() : "";
+    const url = typeof candidate.url === "string" ? candidate.url.trim() : "";
+    if (!name || !url) continue;
+    const providerId = getCustomProviderId(name);
+    const models = Array.isArray(candidate.models) ? [
+      ...new Set(
+        candidate.models.filter((model) => typeof model === "string").map((model) => model.trim()).map((model) => {
+          const providerPrefix = `${providerId}/`;
+          if (model.startsWith(providerPrefix)) {
+            return model.slice(providerPrefix.length);
+          }
+          return model;
+        })
+      )
+    ].filter((model) => model.length > 0) : [];
+    const apiKey = typeof candidate.apiKey === "string" && candidate.apiKey.trim().length > 0 ? candidate.apiKey.trim() : void 0;
+    parsedProviders.push({
+      name,
+      url,
+      ...apiKey ? { apiKey } : {},
+      models
+    });
+  }
+  return parsedProviders;
+}
+function migrateFromAuth(settingsPath) {
+  const authPath = path4.join(chunkIEV2IT3O_cjs.getAppDataDir(), "auth.json");
+  if (!fs2.existsSync(authPath)) return false;
+  let authData;
+  try {
+    authData = JSON.parse(fs2.readFileSync(authPath, "utf-8"));
+  } catch {
+    return false;
+  }
+  const modelKeys = Object.keys(authData).filter((k) => k.startsWith("_"));
+  if (modelKeys.length === 0) return false;
+  let settings;
+  if (fs2.existsSync(settingsPath)) {
+    try {
+      const raw = JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
+      settings = {
+        onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+        models: { ...DEFAULTS.models, ...raw.models },
+        preferences: parsePreferences(raw.preferences),
+        storage: {
+          ...STORAGE_DEFAULTS,
+          ...raw.storage,
+          libsql: { ...STORAGE_DEFAULTS.libsql, ...raw.storage?.libsql },
+          pg: { ...STORAGE_DEFAULTS.pg, ...raw.storage?.pg }
+        },
+        customModelPacks: Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [],
+        customProviders: parseCustomProviders(raw.customProviders),
+        modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {},
+        updateDismissedVersion: typeof raw.updateDismissedVersion === "string" ? raw.updateDismissedVersion : null,
+        lsp: raw.lsp && typeof raw.lsp === "object" ? raw.lsp : void 0
+      };
+    } catch {
+      settings = structuredClone(DEFAULTS);
+    }
+  } else {
+    settings = structuredClone(DEFAULTS);
+  }
+  if (authData._modelRanks && typeof authData._modelRanks === "object") {
+    settings.modelUseCounts = { ...authData._modelRanks, ...settings.modelUseCounts };
+  }
+  for (const key of modelKeys) {
+    const modeMatch = key.match(/^_modeModelId_(.+)$/);
+    if (modeMatch?.[1] && typeof authData[key] === "string" && !settings.models.modeDefaults[modeMatch[1]]) {
+      settings.models.modeDefaults[modeMatch[1]] = authData[key];
+    }
+  }
+  for (const key of modelKeys) {
+    if (key === "_subagentModelId" && typeof authData[key] === "string" && !settings.models.subagentModels["default"]) {
+      settings.models.subagentModels["default"] = authData[key];
+    }
+    const saMatch = key.match(/^_subagentModelId_(.+)$/);
+    if (saMatch?.[1] && typeof authData[key] === "string" && !settings.models.subagentModels[saMatch[1]]) {
+      settings.models.subagentModels[saMatch[1]] = authData[key];
+    }
+  }
+  saveSettings(settings, settingsPath);
+  for (const key of modelKeys) {
+    delete authData[key];
+  }
+  try {
+    fs2.writeFileSync(authPath, JSON.stringify(authData, null, 2), "utf-8");
+  } catch {
+  }
+  return true;
+}
+var LEGACY_VARIED_MODELS = {
+  plan: "openai/gpt-5.3-codex",
+  build: "anthropic/claude-sonnet-4-5",
+  fast: "anthropic/claude-haiku-4-5"
+};
+function migrateLegacyVariedPack(settings) {
+  const legacyPackId = "varied";
+  const customPackId = "custom:varied";
+  const hasLegacyReference = settings.models.activeModelPackId === legacyPackId || settings.onboarding.modePackId === legacyPackId;
+  if (!hasLegacyReference) return false;
+  const existingIdx = settings.customModelPacks.findIndex((p) => p.name === "varied");
+  if (existingIdx >= 0) {
+    const existing = settings.customModelPacks[existingIdx];
+    const modelsMatch = Object.entries(LEGACY_VARIED_MODELS).every(([k, v]) => existing.models[k] === v);
+    if (!modelsMatch) {
+      existing.models = { ...LEGACY_VARIED_MODELS };
+    }
+  } else {
+    settings.customModelPacks.push({
+      name: "varied",
+      models: { ...LEGACY_VARIED_MODELS },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (settings.models.activeModelPackId === legacyPackId) {
+    settings.models.activeModelPackId = customPackId;
+    if (Object.keys(settings.models.modeDefaults).length === 0) {
+      settings.models.modeDefaults = { ...LEGACY_VARIED_MODELS };
+    }
+  }
+  if (settings.onboarding.modePackId === legacyPackId) {
+    settings.onboarding.modePackId = customPackId;
+  }
+  return true;
+}
+function loadSettings(filePath = getSettingsPath()) {
+  migrateFromAuth(filePath);
+  if (!fs2.existsSync(filePath)) return structuredClone(DEFAULTS);
+  try {
+    const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    const settings = {
+      ...raw,
+      onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+      models: { ...DEFAULTS.models, ...raw.models },
+      preferences: parsePreferences(raw.preferences),
+      storage: {
+        ...STORAGE_DEFAULTS,
+        ...raw.storage,
+        libsql: { ...STORAGE_DEFAULTS.libsql, ...raw.storage?.libsql },
+        pg: { ...STORAGE_DEFAULTS.pg, ...raw.storage?.pg }
+      },
+      customModelPacks: Array.isArray(raw.customModelPacks) ? raw.customModelPacks : [],
+      customProviders: parseCustomProviders(raw.customProviders),
+      modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {},
+      updateDismissedVersion: typeof raw.updateDismissedVersion === "string" ? raw.updateDismissedVersion : null,
+      lsp: raw.lsp && typeof raw.lsp === "object" ? raw.lsp : void 0
+    };
+    let settingsChanged = false;
+    if (raw.models?.omModelId && !settings.models.omModelOverride) {
+      settings.models.omModelOverride = raw.models.omModelId;
+      settingsChanged = true;
+    }
+    if (migrateLegacyVariedPack(settings)) {
+      settingsChanged = true;
+    }
+    if (settingsChanged) {
+      saveSettings(settings, filePath);
+    }
+    return settings;
+  } catch {
+    return structuredClone(DEFAULTS);
+  }
+}
+function loadSettingsCached(filePath = getSettingsPath()) {
+  const cached = settingsCache.get(filePath);
+  if (cached) {
+    return cloneSettings(cached);
+  }
+  const settings = loadSettings(filePath);
+  settingsCache.set(filePath, cloneSettings(settings));
+  return cloneSettings(settings);
+}
+var THREAD_ACTIVE_MODEL_PACK_ID_KEY = "activeModelPackId";
+function parseThreadSettings(metadata) {
+  const modeModelIds = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    const modeMatch = key.match(/^modeModelId_(.+)$/);
+    if (modeMatch?.[1] && typeof value === "string" && value.length > 0) {
+      modeModelIds[modeMatch[1]] = value;
+    }
+  }
+  const rawPackId = metadata?.[THREAD_ACTIVE_MODEL_PACK_ID_KEY];
+  const activeModelPackId = typeof rawPackId === "string" && rawPackId.length > 0 ? rawPackId : null;
+  return {
+    activeModelPackId,
+    modeModelIds
+  };
+}
+function resolveThreadActiveModelPackId(settings, builtinPacks, metadata) {
+  const threadSettings = parseThreadSettings(metadata);
+  const isKnownPack = (packId) => {
+    if (packId.startsWith("custom:")) {
+      const name = packId.slice("custom:".length);
+      return settings.customModelPacks.some((p) => p.name === name);
+    }
+    return builtinPacks.some((p) => p.id === packId);
+  };
+  if (threadSettings.activeModelPackId && isKnownPack(threadSettings.activeModelPackId)) {
+    return threadSettings.activeModelPackId;
+  }
+  const allPacks = [
+    ...builtinPacks,
+    ...settings.customModelPacks.map((p) => ({ id: `custom:${p.name}`, models: p.models }))
+  ];
+  for (const pack of allPacks) {
+    const packEntries = Object.entries(pack.models);
+    const threadEntries = Object.keys(threadSettings.modeModelIds);
+    const matches = packEntries.length === threadEntries.length && packEntries.every(([modeId, modelId]) => threadSettings.modeModelIds[modeId] === modelId);
+    if (matches) return pack.id;
+  }
+  if (settings.models.activeModelPackId && isKnownPack(settings.models.activeModelPackId)) {
+    return settings.models.activeModelPackId;
+  }
+  return null;
+}
+function resolveModelDefaults(settings, builtinPacks) {
+  const { activeModelPackId, modeDefaults } = settings.models;
+  if (!activeModelPackId) return modeDefaults;
+  if (activeModelPackId.startsWith("custom:")) {
+    const name = activeModelPackId.slice("custom:".length);
+    const pack = settings.customModelPacks.find((p) => p.name === name);
+    if (pack) return pack.models;
+    return modeDefaults;
+  }
+  const builtin = builtinPacks.find((p) => p.id === activeModelPackId);
+  if (builtin) return builtin.models;
+  return modeDefaults;
+}
+function resolveOmModel(settings, builtinOmPacks) {
+  const { activeOmPackId, omModelOverride } = settings.models;
+  if (!activeOmPackId) return omModelOverride;
+  if (activeOmPackId === "custom") return omModelOverride;
+  const pack = builtinOmPacks.find((p) => p.id === activeOmPackId);
+  if (pack) return pack.modelId;
+  return omModelOverride;
+}
+function saveSettings(settings, filePath = getSettingsPath()) {
+  const dir = path4.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(filePath, JSON.stringify(settings, null, 2), "utf-8");
+  settingsCache.set(filePath, cloneSettings(settings));
+}
+var LSPClient = class {
+  connection = null;
+  process = null;
+  serverInfo;
+  workspaceRoot;
+  diagnostics = /* @__PURE__ */ new Map();
+  initializationOptions = null;
+  constructor(serverInfo, workspaceRoot) {
+    this.serverInfo = serverInfo;
+    this.workspaceRoot = workspaceRoot;
+  }
+  /**
+   * Initialize the LSP connection
+   */
+  async initialize() {
+    const spawnResult = await this.serverInfo.spawn(this.workspaceRoot);
+    if (!spawnResult) {
+      throw new Error("Failed to spawn LSP server");
+    }
+    let initializationOptions = void 0;
+    if ("process" in spawnResult) {
+      this.process = spawnResult.process;
+      initializationOptions = spawnResult.initialization;
+    } else {
+      this.process = spawnResult;
+    }
+    if (!this.process.stdin || !this.process.stdout) {
+      throw new Error("Failed to create LSP process with proper stdio");
+    }
+    const reader = new node_js.StreamMessageReader(this.process.stdout);
+    const writer = new node_js.StreamMessageWriter(this.process.stdin);
+    this.connection = node_js.createMessageConnection(reader, writer);
+    this.connection.onError((error) => {
+    });
+    this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      this.diagnostics.set(params.uri, params.diagnostics);
+    });
+    this.connection.onNotification((_method, _params) => {
+    });
+    this.connection.listen();
+    if (this.process.stderr) {
+      this.process.stderr.on("data", (_data) => {
+      });
+    }
+    this.process.on("error", (_error) => {
+    });
+    this.process.on("exit", (_code, _signal) => {
+    });
+    const initParams = {
+      processId: process.pid,
+      rootUri: `file://${this.workspaceRoot}`,
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: `file://${this.workspaceRoot}`
+        }
+      ],
+      capabilities: {
+        window: {
+          workDoneProgress: true
+        },
+        workspace: {
+          configuration: true
+        },
+        textDocument: {
+          publishDiagnostics: {
+            relatedInformation: true,
+            tagSupport: {
+              valueSet: [1, 2]
+            },
+            versionSupport: false
+          },
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            dynamicRegistration: false,
+            willSave: false,
+            willSaveWaitUntil: false,
+            didSave: false
+          },
+          completion: {
+            dynamicRegistration: false,
+            completionItem: {
+              snippetSupport: false,
+              commitCharactersSupport: false,
+              documentationFormat: ["markdown", "plaintext"],
+              deprecatedSupport: false,
+              preselectSupport: false
+            }
+          },
+          definition: {
+            dynamicRegistration: false,
+            linkSupport: true
+          },
+          typeDefinition: {
+            dynamicRegistration: false,
+            linkSupport: true
+          },
+          implementation: {
+            dynamicRegistration: false,
+            linkSupport: true
+          },
+          references: {
+            dynamicRegistration: false
+          },
+          documentHighlight: {
+            dynamicRegistration: false
+          },
+          documentSymbol: {
+            dynamicRegistration: false,
+            hierarchicalDocumentSymbolSupport: true
+          },
+          codeAction: {
+            dynamicRegistration: false,
+            codeActionLiteralSupport: {
+              codeActionKind: {
+                valueSet: [
+                  "quickfix",
+                  "refactor",
+                  "refactor.extract",
+                  "refactor.inline",
+                  "refactor.rewrite",
+                  "source",
+                  "source.organizeImports"
+                ]
+              }
+            }
+          },
+          hover: {
+            dynamicRegistration: false,
+            contentFormat: ["markdown", "plaintext"]
+          }
+        }
+      }
+    };
+    if (initializationOptions) {
+      initParams.initializationOptions = initializationOptions;
+      this.initializationOptions = initializationOptions;
+    }
+    this.connection.onRequest("workspace/configuration", (params) => {
+      return params.items?.map(() => ({})) || [];
+    });
+    this.connection.onRequest("window/workDoneProgress/create", (_params) => {
+      return null;
+    });
+    await Promise.race([
+      this.connection.sendRequest("initialize", initParams),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("LSP initialize request timed out")), 1e4))
+    ]);
+    try {
+      this.connection.sendNotification("initialized", {});
+    } catch {
+      return;
+    }
+    try {
+      if (this.initializationOptions) {
+        this.connection.sendNotification("workspace/didChangeConfiguration", {
+          settings: this.initializationOptions
+        });
+      } else {
+        this.connection.sendNotification("workspace/didChangeConfiguration", {
+          settings: {}
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Notify the server that a document has been opened
+   */
+  notifyOpen(filePath, content, languageId) {
+    if (!this.connection) return;
+    const uri = `file://${filePath}`;
+    this.diagnostics.delete(uri);
+    this.connection.sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri,
+        languageId,
+        version: 0,
+        text: content
+      }
+    });
+  }
+  /**
+   * Notify the server that a document has changed
+   */
+  notifyChange(filePath, content, version) {
+    if (!this.connection) return;
+    this.connection.sendNotification("textDocument/didChange", {
+      textDocument: {
+        uri: `file://${filePath}`,
+        version
+      },
+      contentChanges: [{ text: content }]
+    });
+  }
+  /**
+   * Wait for diagnostics to be available for a specific file
+   * @param waitForChange If true, waits for diagnostics to change from their initial state
+   */
+  async waitForDiagnostics(filePath, timeoutMs = 5e3, waitForChange = false) {
+    if (!this.connection) return [];
+    const uri = `file://${filePath}`;
+    const startTime = Date.now();
+    const initialDiagnostics = this.diagnostics.get(uri);
+    const initialCount = initialDiagnostics?.length || 0;
+    while (Date.now() - startTime < timeoutMs) {
+      const currentDiagnostics = this.diagnostics.get(uri);
+      const currentCount = currentDiagnostics?.length || 0;
+      if (waitForChange) {
+        if (currentDiagnostics !== void 0 && currentCount !== initialCount) {
+          return currentDiagnostics;
+        }
+      } else {
+        if (currentDiagnostics !== void 0) {
+          return currentDiagnostics;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return waitForChange ? initialDiagnostics || [] : [];
+  }
+  /**
+   * Get hover information for a position
+   */
+  async getHover(filePath, line, character) {
+    if (!this.connection) return null;
+    try {
+      return await this.connection.sendRequest("textDocument/hover", {
+        textDocument: vscodeLanguageserverProtocol.TextDocumentIdentifier.create(`file://${filePath}`),
+        position: vscodeLanguageserverProtocol.Position.create(line, character)
+      });
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get diagnostics for a specific file
+   */
+  getDiagnostics(filePath) {
+    const uri = `file://${filePath}`;
+    return this.diagnostics.get(uri) || [];
+  }
+  /**
+   * Get all diagnostics from all files
+   */
+  getAllDiagnostics() {
+    const allDiagnostics = [];
+    for (const diagnostics of this.diagnostics.values()) {
+      allDiagnostics.push(...diagnostics);
+    }
+    return allDiagnostics;
+  }
+  /**
+   * Notify server that a file was closed
+   */
+  notifyClose(filePath) {
+    if (!this.connection) return;
+    const uri = `file://${filePath}`;
+    this.diagnostics.delete(uri);
+    this.connection.sendNotification("textDocument/didClose", {
+      textDocument: vscodeLanguageserverProtocol.TextDocumentIdentifier.create(uri)
+    });
+  }
+  /**
+   * Restart the LSP client
+   */
+  async restart() {
+    await this.shutdown();
+    await this.initialize();
+  }
+  /**
+   * Shutdown the connection
+   */
+  async shutdown() {
+    if (this.connection) {
+      try {
+        const processAlive = this.process && !this.process.killed;
+        if (processAlive) {
+          await Promise.race([
+            this.connection.sendRequest("shutdown"),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Shutdown request timed out")), 1e3))
+          ]);
+          this.connection.sendNotification("exit");
+        }
+      } catch {
+      }
+      try {
+        this.connection.dispose();
+      } catch {
+      }
+      this.connection = null;
+    }
+    if (this.process) {
+      try {
+        if (!this.process.killed) {
+          this.process.kill();
+        }
+      } catch {
+      }
+      this.process = null;
+    }
+    this.diagnostics = /* @__PURE__ */ new Map();
+  }
+};
+
+// src/lsp/language.ts
+var LANGUAGE_EXTENSIONS = {
+  // TypeScript/JavaScript
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Python
+  ".py": "python",
+  ".pyi": "python",
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // C/C++
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  // Java
+  ".java": "java",
+  // JSON
+  ".json": "json",
+  ".jsonc": "jsonc",
+  // YAML
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  // Markdown
+  ".md": "markdown",
+  // HTML/CSS
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less"
+};
+function getLanguageId(filePath) {
+  const ext = filePath.substring(filePath.lastIndexOf("."));
+  return LANGUAGE_EXTENSIONS[ext];
+}
+
+// src/lsp/server.ts
+function resolveLocalBin(binName, baseDir = process.cwd()) {
+  const binDir = path4.join(baseDir, "node_modules", ".bin");
+  const windowsPath = path4.join(binDir, `${binName}.cmd`);
+  const defaultPath = path4.join(binDir, binName);
+  if (process.platform === "win32" && fs2.existsSync(windowsPath)) {
+    return windowsPath;
+  }
+  return defaultPath;
+}
+function findNearestRoot(cwd, markers) {
+  let current = cwd;
+  while (current !== "/") {
+    for (const marker of markers) {
+      if (fs2.existsSync(path4.join(current, marker))) {
+        return current;
+      }
+    }
+    const parent = path4.join(current, "..");
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+var BUILTIN_SERVERS = {
+  typescript: {
+    id: "typescript",
+    name: "TypeScript Language Server",
+    languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    installHint: "Install typescript-language-server for TypeScript LSP support",
+    root: (cwd) => findNearestRoot(cwd, ["tsconfig.json", "package.json"]),
+    spawn: async (root) => {
+      const requireFromRoot = module$1.createRequire(url.pathToFileURL(path4__namespace.default.join(root, "package.json")));
+      let tsserver;
+      try {
+        tsserver = requireFromRoot.resolve("typescript/lib/tsserver.js");
+      } catch {
+        tsserver = void 0;
+      }
+      if (!tsserver) {
+        return void 0;
+      }
+      const localBin = resolveLocalBin("typescript-language-server", root);
+      const cwdBin = resolveLocalBin("typescript-language-server");
+      let tslsBinary;
+      if (fs2.existsSync(localBin)) {
+        tslsBinary = localBin;
+      } else if (fs2.existsSync(cwdBin)) {
+        tslsBinary = cwdBin;
+      }
+      if (!tslsBinary) {
+        return void 0;
+      }
+      const proc = child_process.spawn(tslsBinary, ["--stdio"], {
+        cwd: root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return {
+        process: proc,
+        initialization: {
+          tsserver: {
+            path: tsserver,
+            logVerbosity: "off"
+          }
+        }
+      };
+    }
+  },
+  eslint: {
+    id: "eslint",
+    name: "ESLint Language Server",
+    languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
+    installHint: "Install eslint-lsp for ESLint diagnostics",
+    root: (cwd) => findNearestRoot(cwd, ["package.json", ".eslintrc.js", ".eslintrc.json", ".eslintrc.yml", ".eslintrc.yaml"]),
+    spawn: (root) => {
+      const binaryPath = resolveLocalBin("eslint-lsp");
+      return child_process.spawn(binaryPath, ["--stdio"], {
+        cwd: root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+  },
+  python: {
+    id: "python",
+    name: "Python Language Server (Pyright)",
+    languageIds: ["python"],
+    installHint: "Install pyright for Python LSP support",
+    root: (cwd) => findNearestRoot(cwd, ["pyproject.toml", "setup.py", "requirements.txt", ".git"]),
+    spawn: (root) => {
+      const localPath = resolveLocalBin("pyright-langserver");
+      const binaryPath = fs2.existsSync(localPath) ? localPath : "pyright-langserver";
+      return child_process.spawn(binaryPath, ["--stdio"], {
+        cwd: root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+  },
+  go: {
+    id: "go",
+    name: "Go Language Server (gopls)",
+    languageIds: ["go"],
+    installHint: "Install gopls for Go LSP support",
+    root: (cwd) => findNearestRoot(cwd, ["go.mod", ".git"]),
+    spawn: (root) => {
+      return child_process.spawn("gopls", ["serve"], {
+        cwd: root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+  },
+  rust: {
+    id: "rust",
+    name: "Rust Language Server (rust-analyzer)",
+    languageIds: ["rust"],
+    installHint: "Install rust-analyzer for Rust LSP support",
+    root: (cwd) => findNearestRoot(cwd, ["Cargo.toml", ".git"]),
+    spawn: (root) => {
+      return child_process.spawn("rust-analyzer", ["--stdio"], {
+        cwd: root,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+  }
+};
+function getServersForFile(filePath, cwd) {
+  const languageId = getLanguageId(filePath);
+  if (!languageId) return [];
+  return Object.values(BUILTIN_SERVERS).filter(
+    (server) => server.languageIds.includes(languageId) && server.root(cwd) !== null
+  );
+}
+var LSP_INIT_TIMEOUT_MS = 15e3;
+var LSP_FAILURE_COOLDOWN_MS = 3e4;
+var LSPManager = class {
+  clients = /* @__PURE__ */ new Map();
+  initializationPromises = /* @__PURE__ */ new Map();
+  clientStatuses = /* @__PURE__ */ new Map();
+  unavailableServers = /* @__PURE__ */ new Map();
+  statusListeners = /* @__PURE__ */ new Set();
+  emitStatusChange() {
+    for (const listener of this.statusListeners) {
+      listener();
+    }
+  }
+  setClientStatus(key, status) {
+    this.clientStatuses.set(key, status);
+    this.emitStatusChange();
+  }
+  getClientKey(filePath, workspaceRoot) {
+    const servers = getServersForFile(filePath, workspaceRoot);
+    if (servers.length === 0) {
+      return { key: "" };
+    }
+    const serverInfo = servers.find(
+      (s) => s.languageIds.includes("typescript") || s.languageIds.includes("javascript") || s.languageIds.includes("python") || s.languageIds.includes("go")
+    ) || servers[0];
+    if (!serverInfo) {
+      return { key: "" };
+    }
+    return {
+      key: `${serverInfo.name}:${workspaceRoot}`,
+      serverInfo
+    };
+  }
+  isInFailureCooldown(key) {
+    const status = this.clientStatuses.get(key);
+    return status?.state === "failed" && Date.now() - status.failedAt < LSP_FAILURE_COOLDOWN_MS;
+  }
+  async initializeClient(key, serverInfo, workspaceRoot) {
+    const startedAt = Date.now();
+    this.unavailableServers.delete(key);
+    this.setClientStatus(key, { state: "initializing", startedAt });
+    const initPromise = (async () => {
+      const client = new LSPClient(serverInfo, workspaceRoot);
+      await client.initialize();
+      this.clients.set(key, client);
+    })();
+    this.initializationPromises.set(key, initPromise);
+    try {
+      await Promise.race([
+        initPromise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("LSP client initialization timed out")), LSP_INIT_TIMEOUT_MS)
+        )
+      ]);
+      const durationMs = Date.now() - startedAt;
+      this.setClientStatus(key, { state: "ready", readyAt: Date.now(), durationMs });
+      logRuntimeProfile("lsp.initialize", durationMs, {
+        key,
+        status: "ready"
+      });
+    } catch (error) {
+      const durationMs = Date.now() - startedAt;
+      const message = error instanceof Error ? error.message : String(error);
+      this.clients.delete(key);
+      if (message === "Failed to spawn LSP server") {
+        this.clientStatuses.delete(key);
+        this.unavailableServers.set(key, {
+          serverName: serverInfo.name,
+          installHint: serverInfo.installHint
+        });
+        this.emitStatusChange();
+        logRuntimeProfile("lsp.initialize", durationMs, {
+          key,
+          status: "unavailable"
+        });
+        return;
+      }
+      this.setClientStatus(key, {
+        state: "failed",
+        failedAt: Date.now(),
+        durationMs,
+        error: message
+      });
+      logRuntimeProfile("lsp.initialize", durationMs, {
+        key,
+        status: "failed",
+        error: message
+      });
+      throw error;
+    } finally {
+      this.initializationPromises.delete(key);
+    }
+  }
+  /**
+   * Get or create an LSP client for a file
+   * Returns null if no LSP server is available for the file
+   */
+  async getClient(filePath, workspaceRoot) {
+    const { key, serverInfo } = this.getClientKey(filePath, workspaceRoot);
+    if (!serverInfo || !key) {
+      return null;
+    }
+    if (this.clients.has(key)) {
+      return this.clients.get(key);
+    }
+    if (this.isInFailureCooldown(key)) {
+      return null;
+    }
+    if (this.initializationPromises.has(key)) {
+      await this.initializationPromises.get(key);
+      return this.clients.get(key) || null;
+    }
+    try {
+      await this.initializeClient(key, serverInfo, workspaceRoot);
+      return this.clients.get(key) || null;
+    } catch {
+      return null;
+    }
+  }
+  prewarmClient(filePath, workspaceRoot) {
+    const { key, serverInfo } = this.getClientKey(filePath, workspaceRoot);
+    if (!serverInfo || !key || this.clients.has(key) || this.initializationPromises.has(key) || this.isInFailureCooldown(key)) {
+      return;
+    }
+    void this.initializeClient(key, serverInfo, workspaceRoot).catch(() => {
+    });
+  }
+  getClientStatus(filePath, workspaceRoot) {
+    const { key } = this.getClientKey(filePath, workspaceRoot);
+    if (!key) return { state: "idle" };
+    return this.clientStatuses.get(key) ?? { state: "idle" };
+  }
+  getInitializingClientCount() {
+    let count = 0;
+    for (const status of this.clientStatuses.values()) {
+      if (status.state === "initializing") {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  getUnavailableClientCount() {
+    return this.unavailableServers.size;
+  }
+  getUnavailableStatusHint() {
+    const unavailable = Array.from(this.unavailableServers.values());
+    if (unavailable.length === 0) {
+      return null;
+    }
+    const first = unavailable[0];
+    if (unavailable.length === 1) {
+      return first?.installHint ?? `${first?.serverName} unavailable`;
+    }
+    return `${first?.installHint ?? `${first?.serverName} unavailable`} (+${unavailable.length - 1} more)`;
+  }
+  subscribeStatusChange(listener) {
+    this.statusListeners.add(listener);
+    return () => {
+      this.statusListeners.delete(listener);
+    };
+  }
+  prewarmWorkspace(workspaceRoot) {
+    const candidates = ["index.ts", "index.js", "main.py", "main.go", "main.rs"];
+    for (const candidate of candidates) {
+      const filePath = path4__namespace.default.join(workspaceRoot, candidate);
+      const { serverInfo } = this.getClientKey(filePath, workspaceRoot);
+      if (serverInfo) {
+        this.prewarmClient(filePath, workspaceRoot);
+        return;
+      }
+    }
+  }
+  /**
+   * Shutdown a specific client
+   */
+  async shutdownClient(workspaceRoot, serverName) {
+    const keysToRemove = [];
+    for (const [key, client] of this.clients.entries()) {
+      if (key.includes(workspaceRoot) && (!serverName || key.startsWith(serverName))) {
+        await client.shutdown();
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      this.clients.delete(key);
+      this.clientStatuses.delete(key);
+      this.unavailableServers.delete(key);
+      this.emitStatusChange();
+    }
+  }
+  /**
+   * Shutdown all clients
+   */
+  async shutdownAll() {
+    const shutdownPromises = Array.from(this.clients.values()).map((client) => client.shutdown());
+    await Promise.all(shutdownPromises);
+    this.clients.clear();
+    this.initializationPromises.clear();
+    this.clientStatuses.clear();
+    this.unavailableServers.clear();
+    this.emitStatusChange();
+  }
+  /**
+   * Get the number of active clients
+   */
+  getActiveClientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Close a document in all active clients
+   * This is useful for tests that reuse the same file path
+   */
+  closeDocument(filePath) {
+    for (const client of this.clients.values()) {
+      try {
+        client.notifyClose(filePath);
+      } catch {
+      }
+    }
+  }
+};
+var lspManager = new LSPManager();
+
+// src/onboarding/packs.ts
+var DEFAULT_PACK_MODE_IDS = ["plan", "build", "fast"];
+var MODE_PRIORITY = ["plan", "build", "fast", "ask"];
+function sortModeIds(modeIds) {
+  return [...modeIds].sort((left, right) => {
+    const leftPriority = MODE_PRIORITY.indexOf(left);
+    const rightPriority = MODE_PRIORITY.indexOf(right);
+    const leftRank = leftPriority === -1 ? Number.MAX_SAFE_INTEGER : leftPriority;
+    const rightRank = rightPriority === -1 ? Number.MAX_SAFE_INTEGER : rightPriority;
+    if (leftRank !== rightRank) return leftRank - rightRank;
+    return left.localeCompare(right);
+  });
+}
+function getModePackOptions(modeDefinitions = []) {
+  if (modeDefinitions.length === 0) {
+    return DEFAULT_PACK_MODE_IDS.map((id) => ({ id, label: id }));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const modes = modeDefinitions.map((definition) => ({
+    id: definition.id.trim(),
+    label: definition.name?.trim() || definition.id.trim(),
+    color: definition.color?.trim()
+  })).filter((mode) => {
+    if (!mode.id || seen.has(mode.id)) return false;
+    seen.add(mode.id);
+    return true;
+  });
+  return sortModeIds(modes.map((mode) => mode.id)).map((id) => modes.find((mode) => mode.id === id)).filter(Boolean);
+}
+function firstAssignedModel(models) {
+  for (const modeId of MODE_PRIORITY) {
+    const modelId = models[modeId];
+    if (modelId) return modelId;
+  }
+  for (const modelId of Object.values(models)) {
+    if (modelId) return modelId;
+  }
+  return "";
+}
+function getFallbackModelForMode(modeId, models) {
+  const candidatesByMode = {
+    ask: ["ask", "fast", "plan", "build"],
+    fast: ["fast", "ask", "plan", "build"],
+    plan: ["plan", "build", "fast", "ask"],
+    build: ["build", "plan", "fast", "ask"]
+  };
+  for (const candidate of candidatesByMode[modeId] ?? [modeId, "fast", "ask", "plan", "build"]) {
+    const modelId = models[candidate];
+    if (modelId) return modelId;
+  }
+  return firstAssignedModel(models);
+}
+function expandPackModels(models, modeIds, options) {
+  const expanded = { ...models };
+  for (const modeId of modeIds) {
+    if (expanded[modeId]) continue;
+    expanded[modeId] = options?.fillMissing ? getFallbackModelForMode(modeId, expanded) : "";
+  }
+  return expanded;
+}
+function getAvailableModePacks(access, savedCustomPacks = [], modeDefinitions = []) {
+  const packs = [];
+  const modeIds = getModePackOptions(modeDefinitions).map((mode) => mode.id);
+  const openaiCodex = "openai/gpt-5.3-codex";
+  const anthropicBuild = access.anthropic === "oauth" ? "anthropic/claude-opus-4-6" : "anthropic/claude-sonnet-4-5";
+  if (access.anthropic) {
+    packs.push({
+      id: "anthropic",
+      name: "Anthropic",
+      description: access.anthropic === "oauth" ? "All Anthropic models via Max subscription" : "All Anthropic models via API key",
+      models: expandPackModels({
+        build: anthropicBuild,
+        plan: anthropicBuild,
+        fast: "anthropic/claude-haiku-4-5"
+      }, modeIds, { fillMissing: true })
+    });
+  }
+  if (access.openai) {
+    packs.push({
+      id: "openai",
+      name: "OpenAI",
+      description: access.openai === "oauth" ? "All OpenAI models via Codex subscription" : "All OpenAI models via API key",
+      models: expandPackModels({
+        build: openaiCodex,
+        plan: openaiCodex,
+        fast: "openai/gpt-5.1-codex-mini"
+      }, modeIds, { fillMissing: true })
+    });
+  }
+  for (const cp of savedCustomPacks) {
+    packs.push({
+      id: `custom:${cp.name}`,
+      name: cp.name,
+      description: "Saved custom pack",
+      models: expandPackModels(cp.models, modeIds, { fillMissing: true })
+    });
+  }
+  const hasCustom = savedCustomPacks.length > 0;
+  packs.push({
+    id: "custom",
+    name: hasCustom ? "New Custom" : "Custom",
+    description: "Choose a model for each mode",
+    models: expandPackModels({}, modeIds)
+  });
+  return packs;
+}
+function getAvailableOmPacks(access) {
+  const packs = [];
+  if (access.google) {
+    packs.push({
+      id: "gemini",
+      name: "Gemini Flash",
+      description: access.google === "oauth" ? "Via Google OAuth" : "Via Google API key",
+      modelId: "google/gemini-2.5-flash"
+    });
+  }
+  if (access.anthropic) {
+    packs.push({
+      id: "anthropic",
+      name: "Claude Haiku",
+      description: access.anthropic === "oauth" ? "Via Max subscription" : "Via Anthropic API key",
+      modelId: "anthropic/claude-haiku-4-5"
+    });
+  }
+  if (access.openai) {
+    packs.push({
+      id: "openai",
+      name: "Codex Mini",
+      description: access.openai === "oauth" ? "Via Codex subscription" : "Via OpenAI API key",
+      modelId: "openai/gpt-5.1-codex-mini"
+    });
+  }
+  if (access.deepseek) {
+    packs.push({
+      id: "deepseek",
+      name: "DeepSeek",
+      description: "Via DeepSeek API key",
+      modelId: "deepseek/deepseek-chat"
+    });
+  }
+  packs.push({
+    id: "custom",
+    name: "Custom",
+    description: "Choose any available model",
+    modelId: ""
+  });
+  return packs;
+}
+var ONBOARDING_VERSION = 1;
+var ThreadLockError = class extends Error {
+  constructor(threadId, ownerPid) {
+    super(`Thread ${threadId} is locked by another process (PID ${ownerPid})`);
+    this.threadId = threadId;
+    this.ownerPid = ownerPid;
+    this.name = "ThreadLockError";
+  }
+};
+function getLocksDir() {
+  const dir = path4__namespace.join(chunkIEV2IT3O_cjs.getAppDataDir(), "locks");
+  if (!fs2__namespace.existsSync(dir)) {
+    fs2__namespace.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getLockPath(threadId) {
+  const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path4__namespace.join(getLocksDir(), `${safeId}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireThreadLock(threadId) {
+  const lockPath = getLockPath(threadId);
+  const myPid = process.pid;
+  if (fs2__namespace.existsSync(lockPath)) {
+    try {
+      const content = fs2__namespace.readFileSync(lockPath, "utf-8").trim();
+      const ownerPid = parseInt(content, 10);
+      if (!isNaN(ownerPid) && ownerPid !== myPid && isProcessAlive(ownerPid)) {
+        throw new ThreadLockError(threadId, ownerPid);
+      }
+    } catch (error) {
+      if (error instanceof ThreadLockError) throw error;
+    }
+  }
+  fs2__namespace.writeFileSync(lockPath, String(myPid), { mode: 420 });
+}
+function releaseThreadLock(threadId) {
+  const lockPath = getLockPath(threadId);
+  const myPid = process.pid;
+  try {
+    if (!fs2__namespace.existsSync(lockPath)) return;
+    const content = fs2__namespace.readFileSync(lockPath, "utf-8").trim();
+    const ownerPid = parseInt(content, 10);
+    if (ownerPid === myPid) {
+      fs2__namespace.unlinkSync(lockPath);
+    }
+  } catch {
+  }
+}
+function releaseAllThreadLocks() {
+  try {
+    const locksDir = getLocksDir();
+    const files = fs2__namespace.readdirSync(locksDir);
+    const myPid = String(process.pid);
+    for (const file of files) {
+      if (!file.endsWith(".lock")) continue;
+      const lockPath = path4__namespace.join(locksDir, file);
+      try {
+        const content = fs2__namespace.readFileSync(lockPath, "utf-8").trim();
+        if (content === myPid) {
+          fs2__namespace.unlinkSync(lockPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+exports.ONBOARDING_VERSION = ONBOARDING_VERSION;
+exports.THREAD_ACTIVE_MODEL_PACK_ID_KEY = THREAD_ACTIVE_MODEL_PACK_ID_KEY;
+exports.ThreadLockError = ThreadLockError;
+exports.acquireThreadLock = acquireThreadLock;
+exports.createHarnessModesFromDefinitions = createHarnessModesFromDefinitions;
+exports.createHarnessSubagentsFromDefinitions = createHarnessSubagentsFromDefinitions;
+exports.formatAgentDefinitionDiagnostics = formatAgentDefinitionDiagnostics;
+exports.getAllowedSubagentIdsForMode = getAllowedSubagentIdsForMode;
+exports.getAvailableModePacks = getAvailableModePacks;
+exports.getAvailableOmPacks = getAvailableOmPacks;
+exports.getCustomProviderId = getCustomProviderId;
+exports.getModeDefinition = getModeDefinition;
+exports.getModePackOptions = getModePackOptions;
+exports.getSubagentModeMap = getSubagentModeMap;
+exports.getSubagentOwnerModes = getSubagentOwnerModes;
+exports.loadAgentDefinitionsCached = loadAgentDefinitionsCached;
+exports.loadSettingsCached = loadSettingsCached;
+exports.logRuntimeProfile = logRuntimeProfile;
+exports.lspManager = lspManager;
+exports.releaseAllThreadLocks = releaseAllThreadLocks;
+exports.releaseThreadLock = releaseThreadLock;
+exports.resolveModelDefaults = resolveModelDefaults;
+exports.resolveOmModel = resolveOmModel;
+exports.resolveThreadActiveModelPackId = resolveThreadActiveModelPackId;
+exports.saveSettings = saveSettings;
+exports.setupDebugLogging = setupDebugLogging;
+exports.toCustomProviderModelId = toCustomProviderModelId;
+//# sourceMappingURL=chunk-PUVEPQQ3.cjs.map
+//# sourceMappingURL=chunk-PUVEPQQ3.cjs.map