mastracode 0.4.0 → 0.5.0

package/dist/{chunk-K4WJUBEC.cjs → chunk-AJEYT7X3.cjs}

@@ -1,10 +1,13 @@
 'use strict';
 
 var chunkS5ZLN7DR_cjs = require('./chunk-S5ZLN7DR.cjs');
-var child_process = require('child_process');
-var fs8 = require('fs');
+var chunkOEDRHUU5_cjs = require('./chunk-OEDRHUU5.cjs');
+var fs9 = require('fs');
+var path2 = require('path');
 var os = require('os');
-var path = require('path');
+var url = require('url');
+var workspace = require('@mastra/core/workspace');
+var child_process = require('child_process');
 var util = require('util');
 var tools = require('@mastra/core/tools');
 var zod = require('zod');
@@ -16,7 +19,6 @@ var treeKill = require('tree-kill');
 var node_js = require('vscode-jsonrpc/node.js');
 var vscodeLanguageserverProtocol = require('vscode-languageserver-protocol');
 var module$1 = require('module');
-var url = require('url');
 var fastestLevenshtein = require('fastest-levenshtein');
 var anthropic = require('@ai-sdk/anthropic');
 var ai = require('ai');
@@ -26,6 +28,7 @@ var core = require('@tavily/core');
 var napi = require('@ast-grep/napi');
 var chalk = require('chalk');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -46,13 +49,418 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs8__namespace = /*#__PURE__*/_interopNamespace(fs8);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var os__default = /*#__PURE__*/_interopDefault(os);
 var o200k_base__default = /*#__PURE__*/_interopDefault(o200k_base);
 var stripAnsi__default = /*#__PURE__*/_interopDefault(stripAnsi);
 var treeKill__default = /*#__PURE__*/_interopDefault(treeKill);
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 
+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",
+    quietMode: false
+  },
+  storage: { ...STORAGE_DEFAULTS },
+  customModelPacks: [],
+  customProviders: [],
+  modelUseCounts: {},
+  updateDismissedVersion: null,
+  lsp: {}
+};
+function getSettingsPath() {
+  return path2.join(chunkS5ZLN7DR_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 = path2.join(chunkS5ZLN7DR_cjs.getAppDataDir(), "auth.json");
+  if (!fs9.existsSync(authPath)) return false;
+  let authData;
+  try {
+    authData = JSON.parse(fs9.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 (fs9.existsSync(settingsPath)) {
+    try {
+      const raw = JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
+      settings = {
+        onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+        models: { ...DEFAULTS.models, ...raw.models },
+        preferences: { ...DEFAULTS.preferences, ...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 {
+    fs9.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 (!fs9.existsSync(filePath)) return structuredClone(DEFAULTS);
+  try {
+    const raw = JSON.parse(fs9.readFileSync(filePath, "utf-8"));
+    const settings = {
+      ...raw,
+      onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
+      models: { ...DEFAULTS.models, ...raw.models },
+      preferences: { ...DEFAULTS.preferences, ...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);
+  }
+}
+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 = path2.dirname(filePath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
+  }
+  fs9.writeFileSync(filePath, JSON.stringify(settings, null, 2), "utf-8");
+}
+var mastraCodeLocalSkillsPath = path2__namespace.default.join(process.cwd(), ".mastracode", "skills");
+var claudeLocalSkillsPath = path2__namespace.default.join(process.cwd(), ".claude", "skills");
+var mastraCodeGlobalSkillsPath = path2__namespace.default.join(os__default.default.homedir(), ".mastracode", "skills");
+var claudeGlobalSkillsPath = path2__namespace.default.join(os__default.default.homedir(), ".claude", "skills");
+function collectSkillPaths(skillsDirs) {
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    if (!fs9__namespace.default.existsSync(skillsDir)) continue;
+    const resolved = fs9__namespace.default.realpathSync(skillsDir);
+    if (!seen.has(resolved)) {
+      seen.add(resolved);
+      paths.push(skillsDir);
+    }
+    try {
+      const entries = fs9__namespace.default.readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) {
+          const linkPath = path2__namespace.default.join(skillsDir, entry.name);
+          const realPath = fs9__namespace.default.realpathSync(linkPath);
+          const stat = fs9__namespace.default.statSync(realPath);
+          if (stat.isDirectory()) {
+            const realParent = path2__namespace.default.dirname(realPath);
+            if (!seen.has(realParent)) {
+              seen.add(realParent);
+              paths.push(realParent);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return paths;
+}
+var skillPaths = collectSkillPaths([
+  mastraCodeLocalSkillsPath,
+  claudeLocalSkillsPath,
+  mastraCodeGlobalSkillsPath,
+  claudeGlobalSkillsPath
+]);
+var WORKSPACE_ID_PREFIX = "mastra-code-workspace";
+function detectPackageRunner(projectPath) {
+  if (fs9.existsSync(path2.join(projectPath, "pnpm-lock.yaml"))) return "pnpm dlx";
+  if (fs9.existsSync(path2.join(projectPath, "bun.lockb")) || fs9.existsSync(path2.join(projectPath, "bun.lock"))) return "bunx";
+  if (fs9.existsSync(path2.join(projectPath, "yarn.lock"))) return "yarn dlx";
+  if (fs9.existsSync(path2.join(projectPath, "package-lock.json"))) return "npx --yes";
+  return "npx --yes";
+}
+function getDynamicWorkspace({ requestContext, mastra: mastra2 }) {
+  const ctx = requestContext.get("harness");
+  const state = ctx?.getState?.();
+  const modeId = ctx?.modeId ?? "build";
+  const rawProjectPath = state?.projectPath;
+  if (!rawProjectPath) {
+    throw new Error("Project path is required");
+  }
+  const projectPath = path2__namespace.default.resolve(rawProjectPath);
+  const workspaceId = `${WORKSPACE_ID_PREFIX}-${projectPath}`;
+  const sandboxPaths = state?.sandboxAllowedPaths ?? [];
+  const allowedPaths = [...skillPaths, ...sandboxPaths.map((p) => path2__namespace.default.resolve(p))];
+  const isPlanMode = modeId === "plan";
+  const planModeTools = {
+    mastra_workspace_write_file: { ...chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES.mastra_workspace_write_file, enabled: false },
+    mastra_workspace_edit_file: { ...chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES.mastra_workspace_edit_file, enabled: false },
+    mastra_workspace_ast_edit: { ...chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES.mastra_workspace_ast_edit, enabled: false }
+  };
+  let existing;
+  try {
+    existing = mastra2?.getWorkspaceById(workspaceId);
+  } catch {
+  }
+  if (existing) {
+    existing.filesystem.setAllowedPaths(allowedPaths);
+    existing.setToolsConfig(isPlanMode ? { ...chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES, ...planModeTools } : chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES);
+    return existing;
+  }
+  const userLsp = loadSettings().lsp ?? {};
+  const mcModulePath = path2.join(path2.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-AJEYT7X3.cjs', document.baseURI).href)))), "..");
+  const lspConfig = {
+    ...userLsp,
+    packageRunner: userLsp.packageRunner || detectPackageRunner(projectPath),
+    // Detected runner is the fallback — user's packageRunner always wins
+    searchPaths: [mcModulePath, ...userLsp.searchPaths ?? []]
+  };
+  return new workspace.Workspace({
+    id: workspaceId,
+    name: "Mastra Code Workspace",
+    filesystem: new workspace.LocalFilesystem({
+      basePath: projectPath,
+      allowedPaths
+    }),
+    sandbox: new workspace.LocalSandbox({
+      workingDirectory: projectPath,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        CLICOLOR_FORCE: "1",
+        TERM: process.env.TERM || "xterm-256color",
+        CI: "true",
+        NONINTERACTIVE: "1",
+        DEBIAN_FRONTEND: "noninteractive"
+      }
+    }),
+    tools: isPlanMode ? { ...chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES, ...planModeTools } : chunkOEDRHUU5_cjs.TOOL_NAME_OVERRIDES,
+    ...skillPaths.length > 0 ? { skills: skillPaths } : {},
+    lsp: lspConfig
+  });
+}
+if (skillPaths.length > 0) {
+  console.info(`Skills loaded from:`);
+  for (const p of skillPaths) {
+    console.info(`  - ${p}`);
+  }
+}
 var enc = new lite.Tiktoken(o200k_base__default.default);
 function sanitizeInput(text) {
   if (!text) return "";
@@ -76,19 +484,19 @@ var ToolError = class extends Error {
 // src/tools/utils.ts
 var fileWriteQueues = /* @__PURE__ */ new Map();
 async function withWriteLock(filePath, fn) {
-  const normalizedPath = path__namespace.resolve(filePath);
+  const normalizedPath = path2__namespace.resolve(filePath);
   const currentQueue = fileWriteQueues.get(normalizedPath) ?? Promise.resolve();
-  let resolve10;
+  let resolve11;
   let reject;
   const ourPromise = new Promise((res, rej) => {
-    resolve10 = res;
+    resolve11 = res;
     reject = rej;
   });
   const queuePromise = currentQueue.catch(() => {
   }).then(async () => {
     try {
       const result = await fn();
-      resolve10(result);
+      resolve11(result);
     } catch (error) {
       reject(error);
     }
@@ -104,7 +512,7 @@ async function withWriteLock(filePath, fn) {
 var SNIPPET_LINES = 4;
 async function readFile(filePath) {
   try {
-    return await fs8.promises.readFile(filePath, "utf8");
+    return await fs9.promises.readFile(filePath, "utf8");
   } catch (e) {
     const error = e instanceof Error ? e : new Error("Unknown error");
     throw new Error(`Failed to read ${filePath}: ${error.message}`);
@@ -112,8 +520,8 @@ async function readFile(filePath) {
 }
 async function writeFile(filePath, content) {
   try {
-    await fs8.promises.mkdir(path__namespace.dirname(filePath), { recursive: true });
-    await fs8.promises.writeFile(filePath, content, "utf8");
+    await fs9.promises.mkdir(path2__namespace.dirname(filePath), { recursive: true });
+    await fs9.promises.writeFile(filePath, content, "utf8");
   } catch (e) {
     const error = e instanceof Error ? e : new Error("Unknown error");
     throw new Error(`Failed to write to ${filePath}: ${error.message}`);
@@ -123,7 +531,7 @@ function makeOutput(fileContent, fileDescriptor, initLine = 1, expandTabs = true
   if (expandTabs) {
     fileContent = fileContent.replace(/\t/g, "    ");
   }
-  const displayPath = path__namespace.isAbsolute(fileDescriptor) ? path__namespace.relative(process.cwd(), fileDescriptor) : fileDescriptor;
+  const displayPath = path2__namespace.isAbsolute(fileDescriptor) ? path2__namespace.relative(process.cwd(), fileDescriptor) : fileDescriptor;
   const lines = fileContent.split("\n");
   const numberedLines = lines.map((line, i) => `${(i + initLine).toString().padStart(6)}	${line}`).join("\n");
   return `Here's the result of running \`cat -n\` on ${displayPath}:
@@ -131,12 +539,12 @@ ${truncateStringForTokenEstimate(numberedLines, 500, false)}
 `;
 }
 async function validatePath(command, filePath) {
-  const absolutePath = path__namespace.isAbsolute(filePath) ? filePath : path__namespace.join(process.cwd(), filePath);
-  if (!path__namespace.isAbsolute(filePath)) {
+  const absolutePath = path2__namespace.isAbsolute(filePath) ? filePath : path2__namespace.join(process.cwd(), filePath);
+  if (!path2__namespace.isAbsolute(filePath)) {
     filePath = absolutePath;
   }
   try {
-    const stats = await fs8.promises.stat(filePath);
+    const stats = await fs9.promises.stat(filePath);
     if (stats.isDirectory() && command !== "view") {
       throw new ToolError(
         `The path ${filePath} is a directory and only the \`view\` command can be used on directories`
@@ -156,23 +564,26 @@ async function validatePath(command, filePath) {
   }
 }
 function isPathAllowed(targetPath, projectRoot, allowedPaths = []) {
-  const resolved = path__namespace.resolve(targetPath);
-  const roots = [projectRoot, ...allowedPaths].map((p) => path__namespace.resolve(p));
-  return roots.some((root) => resolved === root || resolved.startsWith(root + path__namespace.sep));
+  const resolved = path2__namespace.resolve(targetPath);
+  const roots = [projectRoot, ...allowedPaths].map((p) => path2__namespace.resolve(p));
+  return roots.some((root) => resolved === root || resolved.startsWith(root + path2__namespace.sep));
 }
 function assertPathAllowed(targetPath, projectRoot, allowedPaths = []) {
   if (!isPathAllowed(targetPath, projectRoot, allowedPaths)) {
-    const resolvedTarget = path__namespace.resolve(targetPath);
-    const resolvedRoot = path__namespace.resolve(projectRoot);
+    const resolvedTarget = path2__namespace.resolve(targetPath);
+    const resolvedRoot = path2__namespace.resolve(projectRoot);
     throw new ToolError(
       `Access denied: "${resolvedTarget}" is outside the project root "${resolvedRoot}"` + (allowedPaths.length ? ` and allowed paths [${allowedPaths.join(", ")}]` : "") + `. Use /sandbox to add additional allowed paths.`
     );
   }
 }
 function getAllowedPathsFromContext(toolContext) {
-  if (!toolContext?.requestContext) return [];
+  if (!toolContext?.requestContext) {
+    return [...skillPaths];
+  }
   const harnessCtx = toolContext.requestContext.get("harness");
-  return harnessCtx?.getState?.()?.sandboxAllowedPaths ?? harnessCtx?.state?.sandboxAllowedPaths ?? [];
+  const sandboxPaths = harnessCtx?.getState?.()?.sandboxAllowedPaths ?? harnessCtx?.state?.sandboxAllowedPaths ?? [];
+  return [...skillPaths, ...sandboxPaths];
 }
 
 // src/tools/file-view.ts
@@ -206,7 +617,7 @@ ${numberedLines}
 }
 async function readFile2(filePath) {
   try {
-    return await fs8.promises.readFile(filePath, "utf8");
+    return await fs9.promises.readFile(filePath, "utf8");
   } catch (e) {
     const error = e instanceof Error ? e : new Error("Unknown error");
     throw new Error(`Failed to read ${filePath}: ${error.message}`);
@@ -214,19 +625,19 @@ async function readFile2(filePath) {
 }
 async function isDirectory(filePath) {
   try {
-    const stats = await fs8.promises.stat(filePath);
+    const stats = await fs9.promises.stat(filePath);
     return stats.isDirectory();
   } catch {
     return false;
   }
 }
 async function validatePath2(command, filePath) {
-  const absolutePath = path__namespace.isAbsolute(filePath) ? filePath : path__namespace.join(process.cwd(), filePath);
-  if (!path__namespace.isAbsolute(filePath)) {
+  const absolutePath = path2__namespace.isAbsolute(filePath) ? filePath : path2__namespace.join(process.cwd(), filePath);
+  if (!path2__namespace.isAbsolute(filePath)) {
     filePath = absolutePath;
   }
   try {
-    const stats = await fs8.promises.stat(filePath);
+    const stats = await fs9.promises.stat(filePath);
     if (stats.isDirectory() && command !== "view") ;
   } catch (e) {
     const error = e instanceof Error ? e : new Error("Unknown error");
@@ -256,7 +667,7 @@ Usage notes:
       try {
         const { path: filePath, view_range } = context;
         const root = projectRoot || process.cwd();
-        const absolutePath = path__namespace.resolve(root, filePath);
+        const absolutePath = path2__namespace.resolve(root, filePath);
         const allowedPaths = getAllowedPathsFromContext(toolContext);
         assertPathAllowed(absolutePath, root, allowedPaths);
         await validatePath2("view", absolutePath);
@@ -423,7 +834,7 @@ Usage notes:
       const root = projectRoot || process.cwd();
       if (context.cwd) {
         const allowedPaths = getAllowedPathsFromContext(toolContext);
-        const resolvedCwd = path__namespace.resolve(context.cwd);
+        const resolvedCwd = path2__namespace.resolve(context.cwd);
         if (!isPathAllowed(resolvedCwd, root, allowedPaths)) {
           return {
             content: [
@@ -756,9 +1167,9 @@ ${truncateStringForTokenEstimate(cleanOutput, 1e3)}` : "[User aborted command]"
           const pid = subprocess?.pid;
           if (pid) {
             try {
-              await new Promise((resolve10) => {
+              await new Promise((resolve11) => {
                 treeKill__default.default(pid, "SIGKILL", (err) => {
-                  resolve10();
+                  resolve11();
                 });
               });
             } catch {
@@ -1026,7 +1437,7 @@ var LSPClient = class {
           return currentDiagnostics;
         }
       }
-      await new Promise((resolve10) => setTimeout(resolve10, 100));
+      await new Promise((resolve11) => setTimeout(resolve11, 100));
     }
     return waitForChange ? initialDiagnostics || [] : [];
   }
@@ -1117,11 +1528,11 @@ function findNearestRoot(cwd, markers) {
   let current = cwd;
   while (current !== "/") {
     for (const marker of markers) {
-      if (fs8.existsSync(path.join(current, marker))) {
+      if (fs9.existsSync(path2.join(current, marker))) {
         return current;
       }
     }
-    const parent = path.join(current, "..");
+    const parent = path2.join(current, "..");
     if (parent === current) break;
     current = parent;
   }
@@ -1134,7 +1545,7 @@ var BUILTIN_SERVERS = {
     languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
     root: (cwd) => findNearestRoot(cwd, ["tsconfig.json", "package.json"]),
     spawn: async (root) => {
-      const requireFromRoot = module$1.createRequire(url.pathToFileURL(path__namespace.default.join(root, "package.json")));
+      const requireFromRoot = module$1.createRequire(url.pathToFileURL(path2__namespace.default.join(root, "package.json")));
       let tsserver;
       try {
         tsserver = requireFromRoot.resolve("typescript/lib/tsserver.js");
@@ -1144,12 +1555,12 @@ var BUILTIN_SERVERS = {
       if (!tsserver) {
         return void 0;
       }
-      const localBin = path.join(root, "node_modules", ".bin", "typescript-language-server");
-      const cwdBin = path.join(process.cwd(), "node_modules", ".bin", "typescript-language-server");
+      const localBin = path2.join(root, "node_modules", ".bin", "typescript-language-server");
+      const cwdBin = path2.join(process.cwd(), "node_modules", ".bin", "typescript-language-server");
       let tslsBinary;
-      if (fs8.existsSync(localBin)) {
+      if (fs9.existsSync(localBin)) {
         tslsBinary = localBin;
-      } else if (fs8.existsSync(cwdBin)) {
+      } else if (fs9.existsSync(cwdBin)) {
         tslsBinary = cwdBin;
       } else {
         tslsBinary = "npx";
@@ -1176,7 +1587,7 @@ var BUILTIN_SERVERS = {
     languageIds: ["typescript", "typescriptreact", "javascript", "javascriptreact"],
     root: (cwd) => findNearestRoot(cwd, ["package.json", ".eslintrc.js", ".eslintrc.json", ".eslintrc.yml", ".eslintrc.yaml"]),
     spawn: (root) => {
-      const binaryPath = path.join(process.cwd(), "node_modules", ".bin", "eslint-lsp");
+      const binaryPath = path2.join(process.cwd(), "node_modules", ".bin", "eslint-lsp");
       return child_process.spawn(binaryPath, ["--stdio"], {
         cwd: root,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1189,8 +1600,8 @@ var BUILTIN_SERVERS = {
     languageIds: ["python"],
     root: (cwd) => findNearestRoot(cwd, ["pyproject.toml", "setup.py", "requirements.txt", ".git"]),
     spawn: (root) => {
-      const localPath = path.join(process.cwd(), "node_modules", ".bin", "pyright-langserver");
-      const binaryPath = fs8.existsSync(localPath) ? localPath : "pyright-langserver";
+      const localPath = path2.join(process.cwd(), "node_modules", ".bin", "pyright-langserver");
+      const binaryPath = fs9.existsSync(localPath) ? localPath : "pyright-langserver";
       return child_process.spawn(binaryPath, ["--stdio"], {
         cwd: root,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1332,18 +1743,18 @@ var WORKSPACE_MARKERS = [
   "composer.json"
 ];
 function findWorkspaceRoot(filePath) {
-  let currentDir = path__namespace.dirname(path__namespace.resolve(filePath));
-  const root = path__namespace.parse(currentDir).root;
+  let currentDir = path2__namespace.dirname(path2__namespace.resolve(filePath));
+  const root = path2__namespace.parse(currentDir).root;
   let closestProjectRoot = null;
   let searchDir = currentDir;
   while (searchDir !== root) {
-    const hasTsConfig = fs8__namespace.existsSync(path__namespace.join(searchDir, "tsconfig.json"));
-    const hasPackageJson = fs8__namespace.existsSync(path__namespace.join(searchDir, "package.json"));
+    const hasTsConfig = fs9__namespace.existsSync(path2__namespace.join(searchDir, "tsconfig.json"));
+    const hasPackageJson = fs9__namespace.existsSync(path2__namespace.join(searchDir, "package.json"));
     if (hasTsConfig || hasPackageJson) {
       closestProjectRoot = searchDir;
       break;
     }
-    const parentDir = path__namespace.dirname(searchDir);
+    const parentDir = path2__namespace.dirname(searchDir);
     if (parentDir === searchDir) {
       break;
     }
@@ -1352,21 +1763,21 @@ function findWorkspaceRoot(filePath) {
   if (closestProjectRoot) {
     return closestProjectRoot;
   }
-  currentDir = path__namespace.dirname(path__namespace.resolve(filePath));
+  currentDir = path2__namespace.dirname(path2__namespace.resolve(filePath));
   while (currentDir !== root) {
     for (const marker of WORKSPACE_MARKERS) {
-      const markerPath = path__namespace.join(currentDir, marker);
-      if (fs8__namespace.existsSync(markerPath)) {
+      const markerPath = path2__namespace.join(currentDir, marker);
+      if (fs9__namespace.existsSync(markerPath)) {
         return currentDir;
       }
     }
-    const parentDir = path__namespace.dirname(currentDir);
+    const parentDir = path2__namespace.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
     currentDir = parentDir;
   }
-  return path__namespace.dirname(path__namespace.resolve(filePath));
+  return path2__namespace.dirname(path2__namespace.resolve(filePath));
 }
 function removeWhitespace(str) {
   return str.replace(/\t/g, "").replace(/ +/g, "").replace(/^ +| +$/gm, "").replace(/\r?\n/g, "\n").replace(/\s/g, "");
@@ -1696,7 +2107,7 @@ ${divergedMessage ? divergedMessage : ``}Try adjusting your input or the file co
   }
   async isDirectory(filePath) {
     try {
-      const stats = await fs8.promises.stat(filePath);
+      const stats = await fs9.promises.stat(filePath);
       return stats.isDirectory();
     } catch {
       return false;
@@ -1706,9 +2117,10 @@ ${divergedMessage ? divergedMessage : ``}Try adjusting your input or the file co
 var sharedFileEditor = new FileEditor();
 
 // src/tools/string-replace-lsp.ts
-var stringReplaceLspTool = tools.createTool({
-  id: "string_replace_lsp",
-  description: `Edit a file by replacing exact text matches. Returns Language Server Protocol (LSP) diagnostics to show any errors/warnings introduced by your edit.
+function createStringReplaceLspTool(projectRoot) {
+  return tools.createTool({
+    id: "string_replace_lsp",
+    description: `Edit a file by replacing exact text matches. Returns Language Server Protocol (LSP) diagnostics to show any errors/warnings introduced by your edit.
 
 Usage notes:
 - You MUST use the view tool to read a file before editing it. Never edit blind.
@@ -1718,99 +2130,104 @@ Usage notes:
 - Use start_line to narrow the search to a specific region of the file.
 - After editing, real LSP diagnostics are returned (TypeScript errors, linting warnings, etc).
 - For creating NEW files, use the write_file tool instead.`,
-  // requireApproval: true,
-  inputSchema: zod.z.object({
-    path: zod.z.string(),
-    old_str: zod.z.string(),
-    new_str: zod.z.string().optional(),
-    start_line: zod.z.number().optional()
-  }),
-  async execute(context, toolContext) {
-    const { path: filePath, old_str, new_str, start_line } = context;
-    try {
-      const absoluteFilePath = path__namespace.isAbsolute(filePath) ? filePath : path__namespace.join(process.cwd(), filePath);
-      const root = process.cwd();
-      const allowedPaths = getAllowedPathsFromContext(toolContext);
-      assertPathAllowed(absoluteFilePath, root, allowedPaths);
-      const result = await sharedFileEditor.strReplace({
-        path: filePath,
-        old_str,
-        new_str: new_str || "",
-        start_line
-      });
-      let diagnosticOutput = "";
+    // requireApproval: true,
+    inputSchema: zod.z.object({
+      path: zod.z.string(),
+      old_str: zod.z.string(),
+      new_str: zod.z.string().optional(),
+      start_line: zod.z.number().optional()
+    }),
+    async execute(context, toolContext) {
+      const { path: filePath, old_str, new_str, start_line } = context;
       try {
-        const workspaceRoot = findWorkspaceRoot(absoluteFilePath);
-        const client = await lspManager.getClient(absoluteFilePath, workspaceRoot);
-        if (client) {
-          const contentNew = fs8__namespace.readFileSync(absoluteFilePath, "utf-8");
-          const languageId = getLanguageId(absoluteFilePath) || path__namespace.extname(absoluteFilePath).slice(1);
-          client.notifyOpen(absoluteFilePath, contentNew, languageId);
-          client.notifyChange(absoluteFilePath, contentNew, 1);
-          const diagnostics = await client.waitForDiagnostics(absoluteFilePath, 3e3).catch(() => []);
-          if (diagnostics.length > 0) {
-            const seen = /* @__PURE__ */ new Set();
-            const dedup = diagnostics.filter((d) => {
-              const key = `${d.severity}:${d.range.start.line}:${d.range.start.character}:${d.message}`;
-              if (seen.has(key)) return false;
-              seen.add(key);
-              return true;
-            });
-            const errors = dedup.filter((d) => d.severity === 1);
-            const warnings = dedup.filter((d) => d.severity === 2);
-            const info = dedup.filter((d) => d.severity === 3);
-            const hints = dedup.filter((d) => d.severity === 4);
-            const formatDiags = (items) => items.map((d) => `  ${d.range.start.line + 1}:${d.range.start.character + 1} - ${d.message}`).join("\n");
-            let diagnosticText = "";
-            if (errors.length > 0) {
-              diagnosticText += `
+        const root = projectRoot || process.cwd();
+        const absoluteFilePath = path2__namespace.resolve(root, filePath);
+        const allowedPaths = getAllowedPathsFromContext(toolContext);
+        assertPathAllowed(absoluteFilePath, root, allowedPaths);
+        const result = await sharedFileEditor.strReplace({
+          path: absoluteFilePath,
+          old_str,
+          new_str: new_str || "",
+          start_line
+        });
+        let diagnosticOutput = "";
+        try {
+          const workspaceRoot = findWorkspaceRoot(absoluteFilePath);
+          const client = await lspManager.getClient(absoluteFilePath, workspaceRoot);
+          if (client) {
+            const contentNew = fs9__namespace.readFileSync(absoluteFilePath, "utf-8");
+            const languageId = getLanguageId(absoluteFilePath) || path2__namespace.extname(absoluteFilePath).slice(1);
+            client.notifyOpen(absoluteFilePath, contentNew, languageId);
+            client.notifyChange(absoluteFilePath, contentNew, 1);
+            const diagnostics = await client.waitForDiagnostics(absoluteFilePath, 3e3).catch(() => []);
+            if (diagnostics.length > 0) {
+              const seen = /* @__PURE__ */ new Set();
+              const dedup = diagnostics.filter((d) => {
+                const key = `${d.severity}:${d.range.start.line}:${d.range.start.character}:${d.message}`;
+                if (seen.has(key)) return false;
+                seen.add(key);
+                return true;
+              });
+              const errors = dedup.filter((d) => d.severity === 1);
+              const warnings = dedup.filter((d) => d.severity === 2);
+              const info = dedup.filter((d) => d.severity === 3);
+              const hints = dedup.filter((d) => d.severity === 4);
+              const formatDiags = (items) => items.map((d) => `  ${d.range.start.line + 1}:${d.range.start.character + 1} - ${d.message}`).join("\n");
+              let diagnosticText = "";
+              if (errors.length > 0) {
+                diagnosticText += `
 Errors:
 ${formatDiags(errors)}`;
-            }
-            if (warnings.length > 0) {
-              diagnosticText += `
+              }
+              if (warnings.length > 0) {
+                diagnosticText += `
 Warnings:
 ${formatDiags(warnings)}`;
-            }
-            if (info.length > 0) {
-              diagnosticText += `
+              }
+              if (info.length > 0) {
+                diagnosticText += `
 Info:
 ${formatDiags(info)}`;
-            }
-            if (hints.length > 0) {
-              diagnosticText += `
+              }
+              if (hints.length > 0) {
+                diagnosticText += `
 Hints:
 ${formatDiags(hints)}`;
-            }
-            if (diagnosticText) {
-              diagnosticOutput = truncateStringForTokenEstimate(`
+              }
+              if (diagnosticText) {
+                diagnosticOutput = truncateStringForTokenEstimate(`
 
 LSP Diagnostics:${diagnosticText}`, 500, false);
-            }
-          } else {
-            diagnosticOutput = `
+              }
+            } else {
+              diagnosticOutput = `
 
 LSP Diagnostics:
 No errors or warnings`;
+            }
+          }
+        } catch (lspError) {
+          if (process.env.DEBUG === "true") {
+            console.info("string_replace_lsp: failed to retrieve LSP diagnostics", lspError);
           }
         }
-      } catch {
+        return {
+          content: [
+            {
+              type: "text",
+              text: result + diagnosticOutput
+            }
+          ]
+        };
+      } catch (e) {
+        return {
+          error: e instanceof Error ? e.message : JSON.stringify(e, null, 2)
+        };
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: result + diagnosticOutput
-          }
-        ]
-      };
-    } catch (e) {
-      return {
-        error: e instanceof Error ? e.message : JSON.stringify(e, null, 2)
-      };
     }
-  }
-});
+  });
+}
+createStringReplaceLspTool();
 var MAX_GREP_TOKENS = 2e3;
 var rgAvailable = null;
 async function hasRipgrep() {
@@ -1848,7 +2265,7 @@ Usage notes:
     execute: async (context, toolContext) => {
       try {
         const root = projectRoot || process.cwd();
-        const searchPath = context.path ? path__namespace.resolve(root, context.path) : root;
+        const searchPath = context.path ? path2__namespace.resolve(root, context.path) : root;
         const allowedPaths = getAllowedPathsFromContext(toolContext);
         assertPathAllowed(searchPath, root, allowedPaths);
         const maxResults = context.maxResults ?? 100;
@@ -1963,7 +2380,7 @@ async function matchGlob(pattern, searchPath, root) {
     if (result.exitCode !== 0) {
       return matchGlobWithFind(pattern, searchPath);
     }
-    const allFiles = result.stdout.split("\n").filter((f) => f.trim()).map((f) => path__namespace.resolve(searchPath, f));
+    const allFiles = result.stdout.split("\n").filter((f) => f.trim()).map((f) => path2__namespace.resolve(searchPath, f));
     return filterByGlob(allFiles, pattern, searchPath);
   }
   return matchGlobWithFind(pattern, searchPath);
@@ -1997,7 +2414,7 @@ async function matchGlobWithFind(pattern, searchPath) {
 function filterByGlob(files, pattern, basePath) {
   const regex = globToRegex(pattern);
   return files.filter((file) => {
-    const rel = path__namespace.relative(basePath, file);
+    const rel = path2__namespace.relative(basePath, file);
     return regex.test(rel);
   });
 }
@@ -2053,7 +2470,7 @@ function escapeRegex(s) {
 }
 async function getModTime(filePath) {
   try {
-    const stat = await fs8__namespace.promises.stat(filePath);
+    const stat = await fs9__namespace.promises.stat(filePath);
     return stat.mtimeMs;
   } catch {
     return 0;
@@ -2081,7 +2498,7 @@ Usage notes:
     execute: async (context, toolContext) => {
       try {
         const root = projectRoot || process.cwd();
-        const searchPath = context.path ? path__namespace.resolve(root, context.path) : root;
+        const searchPath = context.path ? path2__namespace.resolve(root, context.path) : root;
         const allowedPaths = getAllowedPathsFromContext(toolContext);
         assertPathAllowed(searchPath, root, allowedPaths);
         const matches = await matchGlob(context.pattern, searchPath, root);
@@ -2098,7 +2515,7 @@ Usage notes:
           }))
         );
         withTimes.sort((a, b) => b.mtime - a.mtime);
-        const relativePaths = withTimes.map((f) => path__namespace.relative(root, f.path));
+        const relativePaths = withTimes.map((f) => path2__namespace.relative(root, f.path));
         const header = `Found ${relativePaths.length} file${relativePaths.length !== 1 ? "s" : ""} matching "${context.pattern}":
 
 `;
@@ -2138,17 +2555,17 @@ Usage notes:
       try {
         const root = projectRoot || process.cwd();
         const filePath = context.path;
-        const absolutePath = path__namespace.resolve(root, filePath);
+        const absolutePath = path2__namespace.resolve(root, filePath);
         const allowedPaths = getAllowedPathsFromContext(toolContext);
         assertPathAllowed(absolutePath, root, allowedPaths);
-        const exists = fs8__namespace.existsSync(absolutePath);
-        const dir = path__namespace.dirname(absolutePath);
-        if (!fs8__namespace.existsSync(dir)) {
-          fs8__namespace.mkdirSync(dir, { recursive: true });
+        const exists = fs9__namespace.existsSync(absolutePath);
+        const dir = path2__namespace.dirname(absolutePath);
+        if (!fs9__namespace.existsSync(dir)) {
+          fs9__namespace.mkdirSync(dir, { recursive: true });
         }
-        fs8__namespace.writeFileSync(absolutePath, context.content, "utf-8");
+        fs9__namespace.writeFileSync(absolutePath, context.content, "utf-8");
         const lineCount = context.content.split("\n").length;
-        const relPath = path__namespace.relative(root, absolutePath);
+        const relPath = path2__namespace.relative(root, absolutePath);
         if (exists) {
           return {
             content: `Overwrote ${relPath} (${lineCount} lines)`,
@@ -2294,6 +2711,13 @@ function setAuthStorage2(storage) {
 var CODEX_INSTRUCTIONS = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 IMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;
+var GPT5_MODEL_RE = /^gpt-5(?:\.|-|$)/;
+function getEffectiveThinkingLevel(modelId, level) {
+  if (GPT5_MODEL_RE.test(modelId) && level === "off") {
+    return "low";
+  }
+  return level;
+}
 var THINKING_LEVEL_TO_REASONING_EFFORT = {
   off: void 0,
   low: "low",
@@ -2326,8 +2750,9 @@ function createCodexMiddleware(reasoningEffort) {
   };
 }
 function openaiCodexProvider(modelId = "codex-mini-latest", options) {
-  const level = options?.thinkingLevel ?? "medium";
-  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[level];
+  const requestedLevel = options?.thinkingLevel ?? "medium";
+  const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);
+  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
   const middleware = createCodexMiddleware(reasoningEffort);
   if (process.env.NODE_ENV === "test" || process.env.VITEST) {
     const openai2 = openai.createOpenAI({
@@ -2400,10 +2825,61 @@ function openaiCodexProvider(modelId = "codex-mini-latest", options) {
   });
 }
 var authStorage = new chunkS5ZLN7DR_cjs.AuthStorage();
+var OPENAI_PREFIX = "openai/";
+var CODEX_OPENAI_MODEL_REMAPS = {
+  "gpt-5.3": "gpt-5.3-codex",
+  "gpt-5.2": "gpt-5.2-codex",
+  "gpt-5.1": "gpt-5.1-codex",
+  "gpt-5.1-mini": "gpt-5.1-codex-mini",
+  "gpt-5": "gpt-5-codex"
+};
+function remapOpenAIModelForCodexOAuth(modelId) {
+  if (!modelId.startsWith(OPENAI_PREFIX)) {
+    return modelId;
+  }
+  const openaiModelId = modelId.substring(OPENAI_PREFIX.length);
+  if (openaiModelId.includes("-codex")) {
+    return modelId;
+  }
+  const codexModelId = CODEX_OPENAI_MODEL_REMAPS[openaiModelId];
+  if (!codexModelId) {
+    return modelId;
+  }
+  return `${OPENAI_PREFIX}${codexModelId}`;
+}
+function getAnthropicApiKey() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return process.env.ANTHROPIC_API_KEY;
+  }
+  const storedCred = authStorage.get("anthropic");
+  if (storedCred?.type === "api_key") {
+    return storedCred.key;
+  }
+  return void 0;
+}
+function anthropicApiKeyProvider(modelId, apiKey) {
+  const anthropic$1 = anthropic.createAnthropic({ apiKey });
+  return ai.wrapLanguageModel({
+    model: anthropic$1(modelId),
+    middleware: [promptCacheMiddleware]
+  });
+}
 function resolveModel(modelId, options) {
   authStorage.reload();
+  const [providerId, modelName] = modelId.split("/", 2);
+  const settings = loadSettings();
+  const customProvider = providerId && modelName ? settings.customProviders.find((provider) => {
+    return providerId === getCustomProviderId(provider.name);
+  }) : void 0;
+  if (customProvider) {
+    return new llm.ModelRouterLanguageModel({
+      id: modelId,
+      url: customProvider.url,
+      apiKey: customProvider.apiKey
+    });
+  }
   const isAnthropicModel = modelId.startsWith("anthropic/");
-  const isOpenAIModel = modelId.startsWith("openai/");
+  const isOpenAIModel = modelId.startsWith(OPENAI_PREFIX);
   const isMoonshotModel = modelId.startsWith("moonshotai/");
   if (isMoonshotModel) {
     if (!process.env.MOONSHOT_AI_API_KEY) {
@@ -2415,18 +2891,25 @@ function resolveModel(modelId, options) {
       name: "moonshotai.anthropicv1"
     })(modelId.substring("moonshotai/".length));
   } else if (isAnthropicModel) {
-    return opencodeClaudeMaxProvider(modelId.substring(`anthropic/`.length));
+    const bareModelId = modelId.substring("anthropic/".length);
+    if (authStorage.isLoggedIn("anthropic")) {
+      return opencodeClaudeMaxProvider(bareModelId);
+    }
+    const apiKey = getAnthropicApiKey();
+    if (apiKey) {
+      return anthropicApiKeyProvider(bareModelId, apiKey);
+    }
+    return opencodeClaudeMaxProvider(bareModelId);
   } else if (isOpenAIModel && authStorage.isLoggedIn("openai-codex")) {
-    return openaiCodexProvider(modelId.substring(`openai/`.length), {
+    const resolvedModelId = options?.remapForCodexOAuth ? remapOpenAIModelForCodexOAuth(modelId) : modelId;
+    return openaiCodexProvider(resolvedModelId.substring(OPENAI_PREFIX.length), {
       thinkingLevel: options?.thinkingLevel
     });
   } else {
     return new llm.ModelRouterLanguageModel(modelId);
   }
 }
-function getDynamicModel({
-  requestContext
-}) {
+function getDynamicModel({ requestContext }) {
   const harnessContext = requestContext.get("harness");
   const modelId = harnessContext?.state?.currentModelId;
   if (!modelId) {
@@ -2475,14 +2958,14 @@ End with a structured summary:
 . **Notes**: Follow-up needed (if any)`,
   allowedTools: [
     // Read tools
-    "view",
-    "search_content",
-    "find_files",
+    chunkOEDRHUU5_cjs.MC_TOOLS.VIEW,
+    chunkOEDRHUU5_cjs.MC_TOOLS.SEARCH_CONTENT,
+    chunkOEDRHUU5_cjs.MC_TOOLS.FIND_FILES,
     // Write tools
-    "string_replace_lsp",
-    "write_file",
+    chunkOEDRHUU5_cjs.MC_TOOLS.STRING_REPLACE_LSP,
+    chunkOEDRHUU5_cjs.MC_TOOLS.WRITE_FILE,
     // Execution tool
-    "execute_command",
+    chunkOEDRHUU5_cjs.MC_TOOLS.EXECUTE_COMMAND,
     // Task tracking (built-in harness tools)
     "task_write",
     "task_check"
@@ -2519,7 +3002,7 @@ End with a structured summary:
 . **Details**: Additional context if needed
 
 Keep your summary under 300 words.`,
-  allowedTools: ["view", "search_content", "find_files"]
+  allowedTools: [chunkOEDRHUU5_cjs.MC_TOOLS.VIEW, chunkOEDRHUU5_cjs.MC_TOOLS.SEARCH_CONTENT, chunkOEDRHUU5_cjs.MC_TOOLS.FIND_FILES]
 };
 
 // src/agents/subagents/plan.ts
@@ -2554,7 +3037,7 @@ Structure your plan as:
 . **Risks**: Potential issues or edge cases (if any)
 
 Be specific about code locations (file paths, function names, line numbers). Keep the plan actionable and under 500 words.`,
-  allowedTools: ["view", "search_content", "find_files"]
+  allowedTools: [chunkOEDRHUU5_cjs.MC_TOOLS.VIEW, chunkOEDRHUU5_cjs.MC_TOOLS.SEARCH_CONTENT, chunkOEDRHUU5_cjs.MC_TOOLS.FIND_FILES]
 };
 var MAX_WEB_SEARCH_TOKENS = 2e3;
 var MAX_WEB_EXTRACT_TOKENS = 2e3;
@@ -2665,7 +3148,6 @@ function parseSubagentMeta(content) {
   }) : [];
   return { text, modelId, durationMs, toolCalls };
 }
-var getProjectRoot = () => process.cwd();
 var astSmartEditSchema = zod.z.object({
   path: zod.z.string().describe("File path relative to project root"),
   pattern: zod.z.string().optional().describe("AST pattern to search for (supports $VARIABLE placeholders)"),
@@ -2680,9 +3162,10 @@ var astSmartEditSchema = zod.z.object({
     isDefault: zod.z.boolean().optional()
   }).optional().describe("Import specification for add-import transform")
 });
-var astSmartEditTool = tools.createTool({
-  id: "ast_smart_edit",
-  description: `Edit code using AST-based analysis for intelligent transformations.
+function createAstSmartEditTool(projectRoot) {
+  return tools.createTool({
+    id: "ast_smart_edit",
+    description: `Edit code using AST-based analysis for intelligent transformations.
     
 Supports various code transformations:
 - Pattern-based search and replace with syntax awareness
@@ -2695,92 +3178,100 @@ Examples:
 - Add import: { transform: 'add-import', importSpec: { module: 'react', names: ['useState'] } }
 - Rename function: { transform: 'rename-function', targetName: 'oldFunc', newName: 'newFunc' }
 - Pattern replace: { pattern: 'console.log($ARG)', replacement: 'logger.debug($ARG)' }`,
-  // requireApproval: true,
-  inputSchema: astSmartEditSchema,
-  execute: async ({ path: path12, pattern, replacement, selector, transform, targetName, newName, importSpec }, toolContext) => {
-    try {
-      const projectRoot = getProjectRoot();
-      const filePath = path.resolve(projectRoot, path12);
-      const allowedPaths = getAllowedPathsFromContext(toolContext);
-      assertPathAllowed(filePath, projectRoot, allowedPaths);
-      const content = fs8.readFileSync(filePath, "utf-8");
-      const lang = getLanguageFromPath(path12);
-      const ast = napi.parse(lang, content);
-      const root = ast.root();
-      let modifiedContent = content;
-      let changes = [];
-      if (transform) {
-        switch (transform) {
-          case "add-import":
-            if (!importSpec) {
-              throw new Error("importSpec is required for add-import transform");
-            }
-            modifiedContent = addImport(content, root, importSpec);
-            changes.push(`Added import from '${importSpec.module}'`);
-            break;
-          case "remove-import":
-            if (!targetName) {
-              throw new Error("targetName is required for remove-import transform");
-            }
-            modifiedContent = removeImport(content, root, targetName);
-            changes.push(`Removed import '${targetName}'`);
-            break;
-          case "rename-function":
-            if (!targetName || !newName) {
-              throw new Error("targetName and newName are required for rename-function transform");
-            }
-            const funcResult = renameFunction(content, root, targetName, newName);
-            modifiedContent = funcResult.content;
-            changes.push(`Renamed function '${targetName}' to '${newName}' (${funcResult.count} occurrences)`);
-            break;
-          case "rename-variable":
-            if (!targetName || !newName) {
-              throw new Error("targetName and newName are required for rename-variable transform");
-            }
-            const varResult = renameVariable(content, root, targetName, newName);
-            modifiedContent = varResult.content;
-            changes.push(`Renamed variable '${targetName}' to '${newName}' (${varResult.count} occurrences)`);
-            break;
-          default:
-            throw new Error(`Unsupported transform: ${transform}`);
+    // requireApproval: true,
+    inputSchema: astSmartEditSchema,
+    execute: async ({ path: path13, pattern, replacement, selector, transform, targetName, newName, importSpec }, toolContext) => {
+      try {
+        const root = process.cwd();
+        const filePath = path2.resolve(root, path13);
+        const allowedPaths = getAllowedPathsFromContext(toolContext);
+        assertPathAllowed(filePath, root, allowedPaths);
+        const content = fs9.readFileSync(filePath, "utf-8");
+        const lang = getLanguageFromPath(filePath);
+        const ast = napi.parse(lang, content);
+        const astRoot = ast.root();
+        let modifiedContent = content;
+        const changes = [];
+        if (transform) {
+          switch (transform) {
+            case "add-import":
+              if (!importSpec) {
+                throw new Error("importSpec is required for add-import transform");
+              }
+              modifiedContent = addImport(content, astRoot, importSpec);
+              changes.push(`Added import from '${importSpec.module}'`);
+              break;
+            case "remove-import":
+              if (!targetName) {
+                throw new Error("targetName is required for remove-import transform");
+              }
+              modifiedContent = removeImport(content, astRoot, targetName);
+              changes.push(`Removed import '${targetName}'`);
+              break;
+            case "rename-function":
+              if (!targetName || !newName) {
+                throw new Error("targetName and newName are required for rename-function transform");
+              }
+              const funcResult = renameFunction(content, astRoot, targetName, newName);
+              modifiedContent = funcResult.content;
+              changes.push(`Renamed function '${targetName}' to '${newName}' (${funcResult.count} occurrences)`);
+              break;
+            case "rename-variable":
+              if (!targetName || !newName) {
+                throw new Error("targetName and newName are required for rename-variable transform");
+              }
+              const varResult = renameVariable(content, astRoot, targetName, newName);
+              modifiedContent = varResult.content;
+              changes.push(`Renamed variable '${targetName}' to '${newName}' (${varResult.count} occurrences)`);
+              break;
+            default:
+              throw new Error(`Unsupported transform: ${transform}`);
+          }
+        } else if (pattern && replacement !== void 0) {
+          const result = patternReplace(content, astRoot, pattern, replacement);
+          modifiedContent = result.content;
+          changes.push(`Replaced ${result.count} occurrences of pattern`);
+        } else if (selector) {
+          const matches = astRoot.findAll(selector);
+          const matchInfo = matches.map((match) => ({
+            text: match.text(),
+            range: match.range(),
+            kind: match.kind()
+          }));
+          return {
+            matches: matchInfo.length,
+            details: matchInfo.slice(0, 10)
+            // Limit to first 10 matches
+          };
+        } else {
+          throw new Error("Must provide either transform, pattern/replacement, or selector");
+        }
+        if (modifiedContent !== content) {
+          fs9.writeFileSync(filePath, modifiedContent, "utf-8");
         }
-      } else if (pattern && replacement !== void 0) {
-        const result = patternReplace(content, root, pattern, replacement);
-        modifiedContent = result.content;
-        changes.push(`Replaced ${result.count} occurrences of pattern`);
-      } else if (selector) {
-        const matches = root.findAll(selector);
-        const matchInfo = matches.map((match) => ({
-          text: match.text(),
-          range: match.range(),
-          kind: match.kind()
-        }));
         return {
-          matches: matchInfo.length,
-          details: matchInfo.slice(0, 10)
-          // Limit to first 10 matches
+          success: true,
+          changes,
+          modified: modifiedContent !== content
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (process.env.DEBUG === "true" && error instanceof Error && error.stack) {
+          return {
+            error: message,
+            stack: error.stack
+          };
+        }
+        return {
+          error: message
         };
-      } else {
-        throw new Error("Must provide either transform, pattern/replacement, or selector");
-      }
-      if (modifiedContent !== content) {
-        fs8.writeFileSync(filePath, modifiedContent, "utf-8");
       }
-      return {
-        success: true,
-        changes,
-        modified: modifiedContent !== content
-      };
-    } catch (error) {
-      return {
-        error: error.message,
-        stack: error.stack
-      };
     }
-  }
-});
-function getLanguageFromPath(path12) {
-  const ext = path12.split(".").pop()?.toLowerCase();
+  });
+}
+createAstSmartEditTool();
+function getLanguageFromPath(path13) {
+  const ext = path13.split(".").pop()?.toLowerCase();
   switch (ext) {
     case "ts":
     case "tsx":
@@ -2990,7 +3481,7 @@ var requestSandboxAccessTool = tools.createTool({
   execute: async ({ path: requestedPath, reason }, context) => {
     try {
       const harnessCtx = context?.requestContext?.get("harness");
-      const absolutePath = path__namespace.isAbsolute(requestedPath) ? requestedPath : path__namespace.resolve(process.cwd(), requestedPath);
+      const absolutePath = path2__namespace.isAbsolute(requestedPath) ? requestedPath : path2__namespace.resolve(process.cwd(), requestedPath);
       const projectRoot = process.cwd();
       const allowedPaths = getAllowedPathsFromContext(context);
       if (isPathAllowed(absolutePath, projectRoot, allowedPaths)) {
@@ -3006,8 +3497,8 @@ var requestSandboxAccessTool = tools.createTool({
         };
       }
       const questionId = `sandbox_${++requestCounter}_${Date.now()}`;
-      const answer = await new Promise((resolve10) => {
-        harnessCtx.registerQuestion({ questionId, resolve: resolve10 });
+      const answer = await new Promise((resolve11) => {
+        harnessCtx.registerQuestion({ questionId, resolve: resolve11 });
         harnessCtx.emitEvent({
           type: "sandbox_access_request",
           questionId,
@@ -3048,18 +3539,6 @@ function getAvailableModePacks(access, savedCustomPacks = []) {
   const packs = [];
   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 && access.openai) {
-    packs.push({
-      id: "varied",
-      name: "Varied",
-      description: "Models from multiple providers",
-      models: {
-        build: anthropicBuild,
-        plan: openaiCodex,
-        fast: access.cerebras ? "cerebras/zai-glm-4.7" : "anthropic/claude-haiku-4-5"
-      }
-    });
-  }
   if (access.anthropic) {
     packs.push({
       id: "anthropic",
@@ -3148,155 +3627,6 @@ function getAvailableOmPacks(access) {
   return packs;
 }
 var ONBOARDING_VERSION = 1;
-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"
-  },
-  storage: { ...STORAGE_DEFAULTS },
-  customModelPacks: [],
-  modelUseCounts: {}
-};
-function getSettingsPath() {
-  return path.join(chunkS5ZLN7DR_cjs.getAppDataDir(), "settings.json");
-}
-function migrateFromAuth(settingsPath) {
-  const authPath = path.join(chunkS5ZLN7DR_cjs.getAppDataDir(), "auth.json");
-  if (!fs8.existsSync(authPath)) return false;
-  let authData;
-  try {
-    authData = JSON.parse(fs8.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 (fs8.existsSync(settingsPath)) {
-    try {
-      const raw = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
-      settings = {
-        onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
-        models: { ...DEFAULTS.models, ...raw.models },
-        preferences: { ...DEFAULTS.preferences, ...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 : [],
-        modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {}
-      };
-    } 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 {
-    fs8.writeFileSync(authPath, JSON.stringify(authData, null, 2), "utf-8");
-  } catch {
-  }
-  return true;
-}
-function loadSettings(filePath = getSettingsPath()) {
-  migrateFromAuth(filePath);
-  if (!fs8.existsSync(filePath)) return structuredClone(DEFAULTS);
-  try {
-    const raw = JSON.parse(fs8.readFileSync(filePath, "utf-8"));
-    const settings = {
-      onboarding: { ...DEFAULTS.onboarding, ...raw.onboarding },
-      models: { ...DEFAULTS.models, ...raw.models },
-      preferences: { ...DEFAULTS.preferences, ...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 : [],
-      modelUseCounts: raw.modelUseCounts && typeof raw.modelUseCounts === "object" ? raw.modelUseCounts : {}
-    };
-    if (raw.models?.omModelId && !settings.models.omModelOverride) {
-      settings.models.omModelOverride = raw.models.omModelId;
-      saveSettings(settings, filePath);
-    }
-    return settings;
-  } catch {
-    return structuredClone(DEFAULTS);
-  }
-}
-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 = path.dirname(filePath);
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
-  }
-  fs8.writeFileSync(filePath, JSON.stringify(settings, null, 2), "utf-8");
-}
 var currentThemeMode = "dark";
 function getThemeMode() {
   return currentThemeMode;
@@ -3562,15 +3892,15 @@ var ThreadLockError = class extends Error {
   }
 };
 function getLocksDir() {
-  const dir = path__namespace.join(chunkS5ZLN7DR_cjs.getAppDataDir(), "locks");
-  if (!fs8__namespace.existsSync(dir)) {
-    fs8__namespace.mkdirSync(dir, { recursive: true });
+  const dir = path2__namespace.join(chunkS5ZLN7DR_cjs.getAppDataDir(), "locks");
+  if (!fs9__namespace.existsSync(dir)) {
+    fs9__namespace.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getLockPath(threadId) {
   const safeId = threadId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path__namespace.join(getLocksDir(), `${safeId}.lock`);
+  return path2__namespace.join(getLocksDir(), `${safeId}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -3583,9 +3913,9 @@ function isProcessAlive(pid) {
 function acquireThreadLock(threadId) {
   const lockPath = getLockPath(threadId);
   const myPid = process.pid;
-  if (fs8__namespace.existsSync(lockPath)) {
+  if (fs9__namespace.existsSync(lockPath)) {
     try {
-      const content = fs8__namespace.readFileSync(lockPath, "utf-8").trim();
+      const content = fs9__namespace.readFileSync(lockPath, "utf-8").trim();
       const ownerPid = parseInt(content, 10);
       if (!isNaN(ownerPid) && ownerPid !== myPid && isProcessAlive(ownerPid)) {
         throw new ThreadLockError(threadId, ownerPid);
@@ -3594,17 +3924,17 @@ function acquireThreadLock(threadId) {
       if (error instanceof ThreadLockError) throw error;
     }
   }
-  fs8__namespace.writeFileSync(lockPath, String(myPid), { mode: 420 });
+  fs9__namespace.writeFileSync(lockPath, String(myPid), { mode: 420 });
 }
 function releaseThreadLock(threadId) {
   const lockPath = getLockPath(threadId);
   const myPid = process.pid;
   try {
-    if (!fs8__namespace.existsSync(lockPath)) return;
-    const content = fs8__namespace.readFileSync(lockPath, "utf-8").trim();
+    if (!fs9__namespace.existsSync(lockPath)) return;
+    const content = fs9__namespace.readFileSync(lockPath, "utf-8").trim();
     const ownerPid = parseInt(content, 10);
     if (ownerPid === myPid) {
-      fs8__namespace.unlinkSync(lockPath);
+      fs9__namespace.unlinkSync(lockPath);
     }
   } catch {
   }
@@ -3612,15 +3942,15 @@ function releaseThreadLock(threadId) {
 function releaseAllThreadLocks() {
   try {
     const locksDir = getLocksDir();
-    const files = fs8__namespace.readdirSync(locksDir);
+    const files = fs9__namespace.readdirSync(locksDir);
     const myPid = String(process.pid);
     for (const file of files) {
       if (!file.endsWith(".lock")) continue;
-      const lockPath = path__namespace.join(locksDir, file);
+      const lockPath = path2__namespace.join(locksDir, file);
       try {
-        const content = fs8__namespace.readFileSync(lockPath, "utf-8").trim();
+        const content = fs9__namespace.readFileSync(lockPath, "utf-8").trim();
         if (content === myPid) {
-          fs8__namespace.unlinkSync(lockPath);
+          fs9__namespace.unlinkSync(lockPath);
         }
       } catch {
       }
@@ -3630,13 +3960,14 @@ function releaseAllThreadLocks() {
 }
 
 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.applyThemeMode = applyThemeMode;
-exports.astSmartEditTool = astSmartEditTool;
 exports.createExecuteCommandTool = createExecuteCommandTool;
 exports.createGlobTool = createGlobTool;
 exports.createGrepTool = createGrepTool;
+exports.createStringReplaceLspTool = createStringReplaceLspTool;
 exports.createViewTool = createViewTool;
 exports.createWebExtractTool = createWebExtractTool;
 exports.createWebSearchTool = createWebSearchTool;
@@ -3645,7 +3976,9 @@ exports.executeSubagent = executeSubagent;
 exports.exploreSubagent = exploreSubagent;
 exports.getAvailableModePacks = getAvailableModePacks;
 exports.getAvailableOmPacks = getAvailableOmPacks;
+exports.getCustomProviderId = getCustomProviderId;
 exports.getDynamicModel = getDynamicModel;
+exports.getDynamicWorkspace = getDynamicWorkspace;
 exports.getEditorTheme = getEditorTheme;
 exports.getMarkdownTheme = getMarkdownTheme;
 exports.getSelectListTheme = getSelectListTheme;
@@ -3663,11 +3996,12 @@ exports.requestSandboxAccessTool = requestSandboxAccessTool;
 exports.resolveModel = resolveModel;
 exports.resolveModelDefaults = resolveModelDefaults;
 exports.resolveOmModel = resolveOmModel;
+exports.resolveThreadActiveModelPackId = resolveThreadActiveModelPackId;
 exports.saveSettings = saveSettings;
 exports.setAuthStorage = setAuthStorage;
 exports.setAuthStorage2 = setAuthStorage2;
-exports.stringReplaceLspTool = stringReplaceLspTool;
 exports.theme = theme;
 exports.tintHex = tintHex;
-//# sourceMappingURL=chunk-K4WJUBEC.cjs.map
-//# sourceMappingURL=chunk-K4WJUBEC.cjs.map
+exports.toCustomProviderModelId = toCustomProviderModelId;
+//# sourceMappingURL=chunk-AJEYT7X3.cjs.map
+//# sourceMappingURL=chunk-AJEYT7X3.cjs.map