@ashx-j/lunr 0.2.21 → 0.2.22

package/dist/node-runtime/{chunk-XI77KVKA.js → chunk-TDL7UWJ7.js}

@@ -1,2913 +1,126 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
-  DEFAULT_THINKING_LEVEL,
-  calculateContextTokens,
-  collectEntriesForBranchSummary,
-  compact,
-  estimateContextTokens,
-  estimateTokens,
-  findInitialModel,
-  generateBranchSummary,
-  prepareCompaction,
-  shouldCompact
-} from "./chunk-STERBGUB.js";
-import {
-  DefaultResourceLoader,
-  ExtensionRunner,
-  createSyntheticSourceInfo,
-  emitSessionShutdownEvent,
-  expandPromptTemplate,
-  formatSkillsForPrompt
-} from "./chunk-Y5KOEMBH.js";
-import {
-  stripFrontmatter
-} from "./chunk-QFWG2RVL.js";
-import {
-  createAllToolDefinitions,
-  createLocalBashOperations,
-  createToolDefinitionFromAgentTool,
-  wrapToolDefinition
-} from "./chunk-WKDK4C5P.js";
-import {
-  DEFAULT_MAX_BYTES,
-  truncateTail
-} from "./chunk-53YJI7JU.js";
-import {
-  stripAnsi
-} from "./chunk-KBKMCJDU.js";
-import {
-  getShellConfig,
-  sanitizeBinaryOutput
-} from "./chunk-CSFI6YXL.js";
-import {
-  SettingsManager,
-  require_proper_lockfile
-} from "./chunk-WLLDXJRT.js";
-import {
-  CURRENT_SESSION_VERSION,
-  SessionManager,
-  getDefaultSessionDir,
-  getLatestCompactionEntry
-} from "./chunk-GKLEQ3I4.js";
-import {
-  convertToLlm
-} from "./chunk-FVDOXRUD.js";
-import {
-  clearPlanUsageCache
-} from "./chunk-LTYWTR3V.js";
-import {
-  gateToolCall
-} from "./chunk-6N22HULO.js";
-import {
-  isUserInstructionsPath,
-  loadSelectedUserInstructions
-} from "./chunk-M3LZLQW2.js";
-import {
-  measureStartup,
-  time
-} from "./chunk-PVCDKGR6.js";
-import {
-  MEMORY_TOOL_NAMES
-} from "./chunk-AY6CAJSL.js";
-import {
-  getThemeByName,
-  theme
-} from "./chunk-RNBHABBA.js";
-import {
-  CONFIG_DIR_NAME,
-  VERSION,
-  getAgentDir,
-  getDocsPath,
-  getExamplesPath,
-  getPackageDir,
-  getReadmePath,
-  normalizePath,
-  resolvePath
-} from "./chunk-FQMM2EZ2.js";
-import {
-  __toESM
-} from "./chunk-BRJX2PRC.js";
-
-// packages/coding-agent/dist/core/agent-session-services.js
-import { join as join14 } from "node:path";
-
-// packages/coding-agent/dist/core/model-runtime.js
-import { dirname as dirname5, join as join7 } from "node:path";
-import { createModels, lazyStream as lazyStream2, ModelsError } from "@ashx-j/lunr-ai";
-import * as builtinProviderCatalog from "@ashx-j/lunr-ai/providers/all";
-
-// packages/coding-agent/dist/core/auth-storage.js
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-
-// packages/coding-agent/dist/core/resolve-config-value.js
-import { execSync, spawnSync } from "child_process";
-var commandResultCache = /* @__PURE__ */ new Map(), ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/, ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
-function appendLiteral(parts, value) {
-  if (!value)
-    return;
-  let previousPart = parts[parts.length - 1];
-  if (previousPart?.type === "literal") {
-    previousPart.value += value;
-    return;
-  }
-  parts.push({ type: "literal", value });
-}
-function parseConfigValueTemplate(config) {
-  let parts = [], index = 0;
-  for (; index < config.length; ) {
-    let dollarIndex = config.indexOf("$", index);
-    if (dollarIndex < 0) {
-      appendLiteral(parts, config.slice(index));
-      break;
-    }
-    appendLiteral(parts, config.slice(index, dollarIndex));
-    let nextChar = config[dollarIndex + 1];
-    if (nextChar === "$" || nextChar === "!") {
-      appendLiteral(parts, nextChar), index = dollarIndex + 2;
-      continue;
-    }
-    if (nextChar === "{") {
-      let endIndex = config.indexOf("}", dollarIndex + 2);
-      if (endIndex < 0) {
-        appendLiteral(parts, "$"), index = dollarIndex + 1;
-        continue;
-      }
-      let name = config.slice(dollarIndex + 2, endIndex);
-      ENV_VAR_NAME_RE.test(name) ? parts.push({ type: "env", name }) : appendLiteral(parts, config.slice(dollarIndex, endIndex + 1)), index = endIndex + 1;
-      continue;
-    }
-    let match = config.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
-    if (match) {
-      parts.push({ type: "env", name: match[0] }), index = dollarIndex + 1 + match[0].length;
-      continue;
-    }
-    appendLiteral(parts, "$"), index = dollarIndex + 1;
-  }
-  return parts;
-}
-function parseConfigValueReference(config) {
-  return config.startsWith("!") ? { type: "command", config } : { type: "template", parts: parseConfigValueTemplate(config) };
-}
-function resolveEnvConfigValue(name, env) {
-  return env?.[name] || process.env[name] || void 0;
-}
-function getTemplateEnvVarNames(parts) {
-  let names = [];
-  for (let part of parts)
-    part.type !== "env" || names.includes(part.name) || names.push(part.name);
-  return names;
-}
-function resolveTemplate(parts, env) {
-  let resolved = "";
-  for (let part of parts) {
-    if (part.type === "literal") {
-      resolved += part.value;
-      continue;
-    }
-    let envValue = resolveEnvConfigValue(part.name, env);
-    if (envValue === void 0)
-      return;
-    resolved += envValue;
-  }
-  return resolved;
-}
-function getConfigValueEnvVarNames(config) {
-  let reference = parseConfigValueReference(config);
-  return reference.type === "template" ? getTemplateEnvVarNames(reference.parts) : [];
-}
-function getMissingConfigValueEnvVarNames(config, env) {
-  return getConfigValueEnvVarNames(config).filter((name) => resolveEnvConfigValue(name, env) === void 0);
-}
-function isCommandConfigValue(config) {
-  return parseConfigValueReference(config).type === "command";
-}
-function isConfigValueConfigured(config, env) {
-  return getMissingConfigValueEnvVarNames(config, env).length === 0;
-}
-function resolveConfigValue(config, env) {
-  let reference = parseConfigValueReference(config);
-  return reference.type === "command" ? executeCommand(reference.config) : resolveTemplate(reference.parts, env);
-}
-function executeWithConfiguredShell(command) {
-  try {
-    let { shell, args, commandTransport } = getShellConfig(), commandFromStdin = commandTransport === "stdin", result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
-      encoding: "utf-8",
-      input: commandFromStdin ? command : void 0,
-      timeout: 1e4,
-      stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "ignore"],
-      shell: !1,
-      windowsHide: !0
-    });
-    return result.error ? result.error.code === "ENOENT" ? { executed: !1, value: void 0 } : { executed: !0, value: void 0 } : result.status !== 0 ? { executed: !0, value: void 0 } : { executed: !0, value: (result.stdout ?? "").trim() || void 0 };
-  } catch {
-    return { executed: !1, value: void 0 };
-  }
-}
-function executeWithDefaultShell(command) {
-  try {
-    return execSync(command, {
-      encoding: "utf-8",
-      timeout: 1e4,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim() || void 0;
-  } catch {
-    return;
-  }
-}
-function executeCommandUncached(commandConfig) {
-  let command = commandConfig.slice(1);
-  return process.platform === "win32" ? (() => {
-    let configuredResult = executeWithConfiguredShell(command);
-    return configuredResult.executed ? configuredResult.value : executeWithDefaultShell(command);
-  })() : executeWithDefaultShell(command);
-}
-function executeCommand(commandConfig) {
-  if (commandResultCache.has(commandConfig))
-    return commandResultCache.get(commandConfig);
-  let result = executeCommandUncached(commandConfig);
-  return commandResultCache.set(commandConfig, result), result;
-}
-function resolveConfigValueUncached(config, env) {
-  let reference = parseConfigValueReference(config);
-  return reference.type === "command" ? executeCommandUncached(reference.config) : resolveTemplate(reference.parts, env);
-}
-function resolveConfigValueOrThrow(config, description, env) {
-  let resolvedValue = resolveConfigValueUncached(config, env);
-  if (resolvedValue !== void 0)
-    return resolvedValue;
-  let reference = parseConfigValueReference(config);
-  if (reference.type === "command")
-    throw new Error(`Failed to resolve ${description} from shell command: ${reference.config.slice(1)}`);
-  if (reference.type === "template") {
-    let missingEnvVars = getMissingConfigValueEnvVarNames(config, env);
-    if (missingEnvVars.length === 1)
-      throw new Error(`Failed to resolve ${description} from environment variable: ${missingEnvVars[0]}`);
-    if (missingEnvVars.length > 1)
-      throw new Error(`Failed to resolve ${description} from environment variables: ${missingEnvVars.join(", ")}`);
-  }
-  throw new Error(`Failed to resolve ${description}`);
-}
-function resolveHeadersOrThrow(headers, description, env) {
-  if (!headers)
-    return;
-  let resolved = {};
-  for (let [key, value] of Object.entries(headers))
-    resolved[key] = resolveConfigValueOrThrow(value, `${description} header "${key}"`, env);
-  return Object.keys(resolved).length > 0 ? resolved : void 0;
-}
-
-// packages/coding-agent/dist/core/auth-storage.js
-var AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 384 }, AUTH_LOCK_STALE_MS = 12e4;
-function writeAuthFileAtomic(authPath, contents) {
-  let tmp = `${authPath}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(tmp, contents, AUTH_FILE_WRITE_OPTIONS);
-  try {
-    chmodSync(tmp, 384);
-  } catch {
-  }
-  try {
-    if (process.platform === "win32" && existsSync(authPath)) {
-      writeFileSync(authPath, contents, AUTH_FILE_WRITE_OPTIONS), chmodSync(authPath, 384);
-      return;
-    }
-    renameSync(tmp, authPath);
-    try {
-      chmodSync(authPath, 384);
-    } catch {
-    }
-  } finally {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-  }
-}
-var FileAuthStorageBackend = class {
-  authPath;
-  constructor(authPath = join(getAgentDir(), "auth.json")) {
-    this.authPath = normalizePath(authPath);
-  }
-  ensureParentDir() {
-    let dir = dirname(this.authPath);
-    existsSync(dir) || mkdirSync(dir, { recursive: !0, mode: 448 });
-  }
-  ensureFileExists() {
-    existsSync(this.authPath) || (writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS), chmodSync(this.authPath, 384));
-  }
-  acquireLockSyncWithRetry(path) {
-    let lastError;
-    for (let attempt = 1; attempt <= 10; attempt++)
-      try {
-        return import_proper_lockfile.default.lockSync(path, { realpath: !1, stale: AUTH_LOCK_STALE_MS });
-      } catch (error) {
-        if ((typeof error == "object" && error !== null && "code" in error ? String(error.code) : void 0) !== "ELOCKED" || attempt === 10)
-          throw error;
-        lastError = error;
-        let start = Date.now();
-        for (; Date.now() - start < 20; )
-          ;
-      }
-    throw lastError ?? new Error("Failed to acquire auth storage lock");
-  }
-  withLock(fn) {
-    this.ensureParentDir(), this.ensureFileExists();
-    let release;
-    try {
-      release = this.acquireLockSyncWithRetry(this.authPath);
-      let current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0, { result, next } = fn(current);
-      return next !== void 0 && writeAuthFileAtomic(this.authPath, next), result;
-    } finally {
-      release && release();
-    }
-  }
-  async withLockAsync(fn) {
-    this.ensureParentDir(), this.ensureFileExists();
-    let release, lockCompromised = !1, lockCompromisedError, throwIfCompromised = () => {
-      if (lockCompromised)
-        throw lockCompromisedError ?? new Error("Auth storage lock was compromised");
-    };
-    try {
-      release = await import_proper_lockfile.default.lock(this.authPath, {
-        retries: {
-          retries: 10,
-          factor: 2,
-          minTimeout: 100,
-          maxTimeout: 1e4,
-          randomize: !0
-        },
-        stale: AUTH_LOCK_STALE_MS,
-        onCompromised: (err) => {
-          lockCompromised = !0, lockCompromisedError = err;
-        }
-      }), throwIfCompromised();
-      let current = existsSync(this.authPath) ? readFileSync(this.authPath, "utf-8") : void 0, { result, next } = await fn(current);
-      return throwIfCompromised(), next !== void 0 && writeAuthFileAtomic(this.authPath, next), throwIfCompromised(), result;
-    } finally {
-      if (release)
-        try {
-          await release();
-        } catch {
-        }
-    }
-  }
-}, InMemoryAuthStorageBackend = class {
-  value;
-  withLock(fn) {
-    let { result, next } = fn(this.value);
-    return next !== void 0 && (this.value = next), result;
-  }
-  async withLockAsync(fn) {
-    let { result, next } = await fn(this.value);
-    return next !== void 0 && (this.value = next), result;
-  }
-}, AuthStorage = class _AuthStorage {
-  data = {};
-  storage;
-  constructor(storage) {
-    this.storage = storage, this.reload();
-  }
-  static create(authPath) {
-    return new _AuthStorage(new FileAuthStorageBackend(authPath ?? join(getAgentDir(), "auth.json")));
-  }
-  static fromStorage(storage) {
-    return new _AuthStorage(storage);
-  }
-  static inMemory(data = {}) {
-    let storage = new InMemoryAuthStorageBackend();
-    return storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) })), _AuthStorage.fromStorage(storage);
-  }
-  parseStorageData(content) {
-    return content ? JSON.parse(content) : {};
-  }
-  /**
-   * Reload credentials from storage.
-   */
-  reload() {
-    let content;
-    try {
-      this.storage.withLock((current) => (content = current, { result: void 0 })), this.data = this.parseStorageData(content);
-    } catch {
-    }
-  }
-  async read(provider) {
-    let credential = this.data[provider];
-    return credential?.type !== "api_key" || credential.key === void 0 ? credential : { ...credential, key: resolveConfigValue(credential.key, credential.env) };
-  }
-  async modify(provider, fn) {
-    return this.storage.withLockAsync(async (content) => {
-      let currentData = this.parseStorageData(content), next = await fn(currentData[provider]);
-      if (next === void 0)
-        return this.data = currentData, { result: currentData[provider] };
-      let merged = { ...currentData, [provider]: next };
-      return this.data = merged, { result: next, next: JSON.stringify(merged, null, 2) };
-    });
-  }
-  async delete(provider) {
-    await this.storage.withLockAsync(async (content) => {
-      let currentData = this.parseStorageData(content);
-      return delete currentData[provider], this.data = currentData, { result: void 0, next: JSON.stringify(currentData, null, 2) };
-    });
-  }
-  /** List credential metadata without resolving configured key values. */
-  async list() {
-    return Object.entries(this.data).map(([providerId, credential]) => ({ providerId, type: credential.type }));
-  }
-};
-function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
-  try {
-    return JSON.parse(readFileSync(normalizePath(authPath), "utf-8"))[providerId];
-  } catch {
-    return;
-  }
-}
-
-// packages/coding-agent/dist/core/catalog-cache-scope.js
-import { createHash } from "node:crypto";
-function catalogCacheScope(provider, baseUrl, credential) {
-  let identity = credential?.type === "oauth" ? typeof credential.accountId == "string" ? credential.accountId : credential.refresh || credential.access : credential?.key;
-  return createHash("sha256").update(JSON.stringify([provider, baseUrl.replace(/\/+$/, ""), identity ?? null])).digest("hex");
-}
-
-// packages/coding-agent/dist/core/catalog-merge.js
-import { withOpenAiEffortMetadata, withXaiEffortMetadata } from "@ashx-j/lunr-ai";
-
-// packages/coding-agent/dist/core/official-catalog.js
-import { createHash as createHash2, randomUUID } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// packages/coding-agent/dist/utils/pi-user-agent.js
-function getPiUserAgent(version) {
-  let runtime = process.versions.bun ? `bun/${process.versions.bun}` : `node/${process.version}`;
-  return `pi/${version} (${process.platform}; ${runtime}; ${process.arch})`;
-}
-
-// packages/coding-agent/dist/core/official-catalog.js
-var OFFICIAL_CATALOG_DEFAULT_URL = "https://raw.githubusercontent.com/ashx-j/lunR/master/catalog", VERSIONED_CATALOG_URL = "https://raw.githubusercontent.com/ashx-j/lunR/model-catalog/catalog", OFFICIAL_CATALOG_TIMEOUT_MS = 4e3, OFFICIAL_CATALOG_CACHE_FILENAME = "official-catalog-cache.json", THINKING_LEVEL_KEYS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"], META_KEYS = /* @__PURE__ */ new Set(["version", "updatedAt", "generatedAt", "sourceCommit", "providerCount", "modelCount"]), BUNDLED_OFFICIAL_CATALOG = {
-  version: 1,
-  updatedAt: "2026-08-15T00:00:00Z",
-  models: [
-    {
-      id: "grok-4.6",
-      name: "Grok 4.6",
-      api: "openai-completions",
-      provider: "xai",
-      baseUrl: "https://api.x.ai/v1",
-      reasoning: !0,
-      input: ["text", "image"],
-      cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
-      contextWindow: 5e5,
-      maxTokens: 5e5
-    }
-  ]
-};
-function officialCatalogCachePath(agentDir = getAgentDir()) {
-  return join2(agentDir, OFFICIAL_CATALOG_CACHE_FILENAME);
-}
-function officialCatalogBaseUrl(override) {
-  return ((override ?? process.env.LUNR_OFFICIAL_CATALOG_URL)?.trim() || OFFICIAL_CATALOG_DEFAULT_URL).replace(/\/+$/, "");
-}
-function officialCatalogUrlFor(path, base) {
-  let normalized = path.replace(/^\/+/, "");
-  return `${officialCatalogBaseUrl(base)}/${normalized}`;
-}
-function modelKey(provider, id) {
-  return `${provider}/${id}`;
-}
-function isRecord(value) {
-  return typeof value == "object" && value !== null && !Array.isArray(value);
-}
-function asFiniteNumber(value) {
-  if (typeof value == "number" && Number.isFinite(value))
-    return value;
-  if (typeof value == "string" && value.trim()) {
-    let parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-}
-function parseCost(value) {
-  if (!isRecord(value))
-    return;
-  let input = asFiniteNumber(value.input), output = asFiniteNumber(value.output);
-  if (!(input === void 0 || output === void 0))
-    return {
-      input,
-      output,
-      cacheRead: asFiniteNumber(value.cacheRead) ?? 0,
-      cacheWrite: asFiniteNumber(value.cacheWrite) ?? 0,
-      ...Array.isArray(value.tiers) ? {
-        tiers: value.tiers.flatMap((tier) => {
-          if (!isRecord(tier) || !(typeof tier.inputTokensAbove == "number" && tier.inputTokensAbove >= 0))
-            return [];
-          let rates = parseCost({
-            input: tier.input,
-            output: tier.output,
-            cacheRead: tier.cacheRead,
-            cacheWrite: tier.cacheWrite
-          });
-          return rates ? [{ ...rates, inputTokensAbove: tier.inputTokensAbove }] : [];
-        })
-      } : {}
-    };
-}
-function parseInput(value) {
-  if (!Array.isArray(value))
-    return;
-  let input = [];
-  for (let entry of value)
-    (entry === "text" || entry === "image") && input.push(entry);
-  return input.length > 0 ? input : void 0;
-}
-function parseThinkingLevelMap(value) {
-  if (!isRecord(value))
-    return;
-  let map = {}, any = !1;
-  for (let level of THINKING_LEVEL_KEYS) {
-    let mapped = value[level];
-    (mapped === null || typeof mapped == "string") && (map[level] = mapped, any = !0);
-  }
-  return any ? map : void 0;
-}
-function parseHeaders(value) {
-  if (!isRecord(value))
-    return;
-  let headers = {};
-  for (let [name, headerValue] of Object.entries(value))
-    typeof headerValue == "string" && (headers[name] = headerValue);
-  return Object.keys(headers).length > 0 ? headers : void 0;
-}
-function parseOfficialEntry(value) {
-  if (!isRecord(value))
-    return;
-  let id = typeof value.id == "string" ? value.id.trim() : "", provider = typeof value.provider == "string" ? value.provider.trim() : "";
-  if (!id || !provider)
-    return;
-  let api = typeof value.api == "string" && value.api.trim() ? value.api.trim() : "openai-completions", name = typeof value.name == "string" && value.name.trim() ? value.name.trim() : id, baseUrl = typeof value.baseUrl == "string" ? value.baseUrl.trim() : "", cost = parseCost(value.cost) ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, input = parseInput(value.input) ?? ["text"], compat = isRecord(value.compat) ? value.compat : void 0, thinkingLevelMap = parseThinkingLevelMap(value.thinkingLevelMap), headers = parseHeaders(value.headers);
-  return {
-    id,
-    ...isRecord(value.catalog) && value.catalog.source === "provider" && Array.isArray(value.catalog.supplied) ? { catalog: value.catalog } : {},
-    name,
-    api,
-    provider,
-    baseUrl,
-    reasoning: value.reasoning === !0,
-    input,
-    cost,
-    contextWindow: asFiniteNumber(value.contextWindow) ?? 128e3,
-    maxTokens: asFiniteNumber(value.maxTokens) ?? 8192,
-    ...compat ? { compat } : {},
-    ...thinkingLevelMap ? { thinkingLevelMap } : {},
-    ...headers ? { headers } : {}
-  };
-}
-function catalogFile(models, value) {
-  let version = value ? asFiniteNumber(value.version) ?? 1 : 1, updatedAt = value && typeof value.updatedAt == "string" && value.updatedAt.trim() ? value.updatedAt : "";
-  return { version, updatedAt, models };
-}
-function parseKeyedCatalog(value) {
-  let models = [];
-  for (let [key, entry] of Object.entries(value))
-    if (!(META_KEYS.has(key) || !isRecord(entry))) {
-      if (typeof entry.id == "string") {
-        let parsed = parseOfficialEntry(entry);
-        parsed && models.push(parsed);
-        continue;
-      }
-      for (let [modelId, model] of Object.entries(entry)) {
-        if (!isRecord(model))
-          continue;
-        let parsed = parseOfficialEntry({
-          ...model,
-          id: typeof model.id == "string" && model.id.trim() ? model.id : modelId,
-          provider: typeof model.provider == "string" && model.provider.trim() ? model.provider : key
-        });
-        parsed && models.push(parsed);
-      }
-    }
-  return models.length > 0 ? catalogFile(models, value) : void 0;
-}
-function parseOfficialCatalog(value) {
-  if (isRecord(value)) {
-    if (Array.isArray(value.models)) {
-      let models = [];
-      for (let entry of value.models) {
-        let parsed = parseOfficialEntry(entry);
-        parsed && models.push(parsed);
-      }
-      return catalogFile(models, value);
-    }
-    if (!("models" in value))
-      return parseKeyedCatalog(value);
-  }
-}
-function parseProviderIndex(value) {
-  if (!(!Array.isArray(value) || !value.every((entry) => typeof entry == "string")))
-    return value;
-}
-function readCatalogFile(path) {
-  try {
-    return existsSync2(path) ? parseOfficialCatalog(JSON.parse(readFileSync2(path, "utf-8"))) : void 0;
-  } catch {
-    return;
-  }
-}
-function bundledCatalogCandidates() {
-  let here = dirname2(fileURLToPath(new URL("../core/official-catalog.js", import.meta.url).href)), packageDir = getPackageDir();
-  return [
-    join2(packageDir, "dist", "catalog", "models.json"),
-    join2(packageDir, "..", "..", "catalog", "models.json"),
-    join2(here, "../../../../catalog/models.json"),
-    join2(packageDir, "catalog", "models.json"),
-    join2(here, "../catalog/models.json"),
-    join2(here, "models.json"),
-    join2(packageDir, "dist", "catalog", "official-models.json"),
-    join2(packageDir, "..", "..", "catalog", "official-models.json"),
-    join2(here, "../../../../catalog/official-models.json"),
-    join2(here, "official-models.json"),
-    join2(here, "../catalog/official-models.json")
-  ];
-}
-function loadBundledOfficialCatalog() {
-  for (let path of bundledCatalogCandidates()) {
-    let parsed = readCatalogFile(path);
-    if (parsed)
-      return parsed;
-  }
-  return BUNDLED_OFFICIAL_CATALOG;
-}
-function loadCachedOfficialCatalog(cachePath) {
-  if (cachePath)
-    return readCatalogFile(cachePath);
-}
-function writeOfficialCatalogCache(catalog, cachePath) {
-  let temporary = `${cachePath}.${randomUUID()}.tmp`;
-  try {
-    mkdirSync2(dirname2(cachePath), { recursive: !0, mode: 448 }), writeFileSync2(temporary, `${JSON.stringify(catalog, null, 2)}
-`, { encoding: "utf-8", mode: 384 }), renameSync2(temporary, cachePath);
-  } catch {
-  } finally {
-    try {
-      unlinkSync2(temporary);
-    } catch {
-    }
-  }
-}
-function officialModelsByProvider(catalog) {
-  let byProvider = /* @__PURE__ */ new Map();
-  for (let model of catalog.models) {
-    let list = byProvider.get(model.provider) ?? [];
-    list.push(model), byProvider.set(model.provider, list);
-  }
-  return byProvider;
-}
-function mergeOfficialCatalogByProvider(base, replacements, updatedAt) {
-  let byProvider = officialModelsByProvider(base);
-  for (let [providerId, models] of replacements)
-    byProvider.set(providerId, models);
-  return {
-    version: base.version || 1,
-    updatedAt: updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    models: [...byProvider.values()].flat()
-  };
-}
-function officialCatalogBase(bundled, cachePath) {
-  let cached = loadCachedOfficialCatalog(cachePath);
-  return cached ? mergeOfficialCatalogByProvider(bundled, officialModelsByProvider(cached), cached.updatedAt) : bundled;
-}
-function preferOfficialCatalog(previous, next) {
-  return next.source === "github" ? next : previous?.source === "github" ? { ...previous, errors: next.errors } : next;
-}
-function officialModelKeys(catalog) {
-  return new Set(catalog.models.map((model) => modelKey(model.provider, model.id)));
-}
-var ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-function officialEntryToModel(entry, template) {
-  return {
-    catalog: entry.catalog,
-    id: entry.id,
-    name: entry.name,
-    api: entry.api || template?.api || "openai-completions",
-    provider: entry.provider,
-    baseUrl: entry.baseUrl || template?.baseUrl || "",
-    reasoning: entry.reasoning,
-    input: entry.input.length > 0 ? entry.input : template?.input ?? ["text"],
-    cost: entry.cost ?? template?.cost ?? ZERO_COST,
-    contextWindow: entry.contextWindow,
-    maxTokens: entry.maxTokens,
-    compat: entry.compat ?? template?.compat,
-    thinkingLevelMap: entry.thinkingLevelMap ?? template?.thinkingLevelMap,
-    headers: entry.headers ?? template?.headers
-  };
-}
-function resolveBundledCatalog(bundled) {
-  return bundled || loadBundledOfficialCatalog();
-}
-function fallbackCatalog(bundled, cachePath) {
-  let cached = loadCachedOfficialCatalog(cachePath);
-  if (cached)
-    return { catalog: cached, source: "cache" };
-  let resolved = resolveBundledCatalog(bundled);
-  return resolved.models.length > 0 ? { catalog: resolved, source: "bundled" } : { catalog: BUNDLED_OFFICIAL_CATALOG, source: "bundled" };
-}
-async function fetchJson(url, options) {
-  let controller = new AbortController(), timer = setTimeout(() => controller.abort(), options.timeoutMs), onParentAbort = () => controller.abort();
-  options.signal?.addEventListener("abort", onParentAbort, { once: !0 }), options.signal?.aborted && controller.abort();
-  try {
-    let abortError = () => {
-      let error = new Error("The operation was aborted");
-      return error.name = "AbortError", error;
-    };
-    return await Promise.race([
-      (async () => {
-        let response = await options.fetchImpl(url, {
-          headers: options.headers,
-          signal: controller.signal
-        });
-        return response.ok ? { ok: !0, value: await response.json() } : { ok: !1, status: response.status };
-      })(),
-      new Promise((_, reject) => {
-        controller.signal.addEventListener("abort", () => reject(abortError()), { once: !0 }), controller.signal.aborted && reject(abortError());
-      })
-    ]);
-  } catch {
-    return { ok: !1 };
-  } finally {
-    clearTimeout(timer), options.signal?.removeEventListener("abort", onParentAbort);
-  }
-}
-async function loadOfficialCatalog(options = {}) {
-  let cachePath = options.cachePath;
-  if (!options.allowNetwork)
-    return fallbackCatalog(options.bundled, cachePath);
-  let bundled = resolveBundledCatalog(options.bundled), timeoutMs = options.timeoutMs ?? OFFICIAL_CATALOG_TIMEOUT_MS, fetchImpl = options.fetchImpl ?? fetch, headers = {
-    accept: "application/json",
-    "User-Agent": getPiUserAgent(VERSION)
-  }, fetchOptions = { timeoutMs, signal: options.signal, fetchImpl, headers }, unavailable = () => ({
-    ...fallbackCatalog(bundled, cachePath),
-    errors: Object.fromEntries((options.providerIds ?? []).map((id) => [id, "Published catalog unavailable; using cached metadata"]))
-  }), base = options.url ?? officialCatalogBaseUrl(), manifest;
-  if (!options.url && !process.env.LUNR_OFFICIAL_CATALOG_URL) {
-    let result = await fetchJson(`${VERSIONED_CATALOG_URL}/publication.json`, fetchOptions);
-    result.ok && isRecord(result.value) && result.value.version === 2 && typeof result.value.revision == "string" && /^sha256-[a-f0-9]{64}$/.test(result.value.revision) && isRecord(result.value.shards) && parseProviderIndex(result.value.providers) && (manifest = result.value, base = `${VERSIONED_CATALOG_URL}/snapshots/${result.value.revision}`);
-  }
-  try {
-    let indexResult = manifest ? { ok: !0, value: manifest.providers } : await fetchJson(officialCatalogUrlFor("providers.json", base), fetchOptions);
-    if (!indexResult.ok)
-      return unavailable();
-    let index = parseProviderIndex(indexResult.value);
-    if (!index)
-      return unavailable();
-    let wanted = new Set(index), shardIds = (options.providerIds ?? []).filter((providerId) => wanted.has(providerId));
-    if (shardIds.length === 0)
-      return fallbackCatalog(bundled, cachePath);
-    let replacements = /* @__PURE__ */ new Map(), errors = {};
-    if (await Promise.all(shardIds.map(async (providerId) => {
-      let result = await fetchJson(officialCatalogUrlFor(`providers/${encodeURIComponent(providerId)}.json`, base), fetchOptions);
-      if (!result.ok) {
-        errors[providerId] = "Catalog shard unavailable; using cached metadata";
-        return;
-      }
-      if (manifest && manifest.shards[providerId] !== createHash2("sha256").update(JSON.stringify(result.value)).digest("hex")) {
-        errors[providerId] = "Catalog shard checksum mismatch; using cached metadata";
-        return;
-      }
-      let parsed = parseOfficialCatalog(result.value);
-      if (!parsed || parsed.models.length === 0 || parsed.models.some((model) => model.provider !== providerId)) {
-        errors[providerId] = "Invalid catalog shard; using cached metadata";
-        return;
-      }
-      replacements.set(providerId, parsed.models);
-    })), replacements.size === 0)
-      return { ...fallbackCatalog(bundled, cachePath), errors };
-    let catalog = mergeOfficialCatalogByProvider(officialCatalogBase(bundled, cachePath), replacements, typeof manifest?.generatedAt == "string" ? manifest.generatedAt : void 0);
-    return cachePath && writeOfficialCatalogCache(catalog, cachePath), { catalog, source: "github", ...Object.keys(errors).length ? { errors } : {} };
-  } catch {
-    return unavailable();
-  }
-}
-
-// packages/coding-agent/dist/core/catalog-merge.js
-function mergeCatalogLayers(args) {
-  let byId = /* @__PURE__ */ new Map();
-  for (let model of args.bakedIn)
-    byId.set(model.id, model);
-  for (let model of args.live ?? [])
-    byId.set(model.id, model);
-  for (let model of args.user ?? [])
-    byId.set(model.id, model);
-  for (let model of args.official ?? [])
-    byId.set(model.id, model);
-  let seen = /* @__PURE__ */ new Set(), result = [];
-  for (let baked of args.bakedIn) {
-    let merged = byId.get(baked.id);
-    merged && (result.push(merged), seen.add(baked.id));
-  }
-  for (let model of [...args.live ?? [], ...args.user ?? [], ...args.official ?? []]) {
-    if (seen.has(model.id))
-      continue;
-    let winner = byId.get(model.id);
-    winner && (result.push(winner), seen.add(model.id));
-  }
-  let liveById = new Map((args.live ?? []).map((model) => [model.id, model])), pricedIds = new Set([...args.bakedIn, ...args.official ?? [], ...args.user ?? []].filter((model) => model.catalog?.pricing !== "unknown").map((model) => model.id));
-  return result.map((model) => {
-    let resolved = withXaiEffortMetadata(model);
-    model.catalog?.supplied.includes("thinkingLevelMap") || (resolved = withOpenAiEffortMetadata(resolved));
-    let live = liveById.get(model.id);
-    if (!live?.catalog)
-      return resolved;
-    resolved = { ...resolved, catalog: { ...live.catalog } };
-    for (let field of live.catalog.supplied)
-      Object.assign(resolved, { [field]: live[field] });
-    return (pricedIds.has(model.id) || live.catalog.supplied.includes("cost")) && delete resolved.catalog.pricing, resolved;
-  });
-}
-var CatalogOverlaySource = class {
-  official = /* @__PURE__ */ new Map();
-  user = /* @__PURE__ */ new Map();
-  live = /* @__PURE__ */ new Map();
-  setOfficial(models) {
-    this.official = groupByProvider(models);
-  }
-  setUser(models) {
-    this.user = groupByProvider(models);
-  }
-  setLive(providerId, models) {
-    this.live.set(providerId, [...models]);
-  }
-  officialFor(providerId) {
-    return this.official.get(providerId) ?? [];
-  }
-  userFor(providerId) {
-    return this.user.get(providerId) ?? [];
-  }
-  liveFor(providerId) {
-    return this.live.get(providerId) ?? [];
-  }
-  /** Codex's complete account catalog is authoritative for picker availability only. */
-  isAvailable(model) {
-    if (model.catalog?.hidden)
-      return !1;
-    let live = this.liveFor(model.provider);
-    return model.provider !== "openai-codex" || !live.length || live.some((row) => row.id === model.id && !row.catalog?.hidden);
-  }
-};
-function groupByProvider(models) {
-  let byProvider = /* @__PURE__ */ new Map();
-  for (let model of models) {
-    let list = byProvider.get(model.provider) ?? [];
-    list.push(model), byProvider.set(model.provider, list);
-  }
-  return byProvider;
-}
-function withCatalogOverlay(provider, overlay) {
-  let bakedIn = () => provider.getModels();
-  return {
-    ...provider,
-    getModels: () => mergeCatalogLayers({
-      bakedIn: bakedIn(),
-      live: overlay.liveFor(provider.id),
-      user: overlay.userFor(provider.id),
-      official: overlay.officialFor(provider.id)
-    })
-  };
-}
-function formatCatalogRefreshSummary(input) {
-  let parts = [];
-  if (input.official?.source === "github") {
-    let evicted = input.official.evictedUserRows > 0 ? `; replaced ${input.official.evictedUserRows} user-filled row` : "", plural = input.official.evictedUserRows === 1 ? "" : input.official.evictedUserRows > 0 ? "s" : "";
-    parts.push(`Official catalog updated (${input.official.modelCount} models)${evicted}${plural}.`);
-  }
-  let refreshed = [], failed = [];
-  for (let provider of input.providers)
-    if (provider.status === "ok") {
-      let added = provider.added ?? 0, total = provider.total ?? 0;
-      refreshed.push(added > 0 ? `${provider.id} (+${added})` : `${provider.id} (${total})`);
-    } else provider.status === "timeout" ? failed.push(`${provider.id} timed out (cached)`) : provider.status === "error" && failed.push(formatLiveProviderError(provider));
-  return refreshed.length > 0 ? parts.push(`Refreshed ${refreshed.join(", ")}.`) : input.providers.some((provider) => provider.status === "ok") && parts.push("Refreshed model catalogs."), failed.length > 0 && parts.push(`${failed.join("; ")}.`), input.asked && input.asked.length > 0 && parts.push(`Asked for missing metadata on ${input.asked.join(", ")}.`), input.extraDefaults && input.extraDefaults > 0 && parts.push(`+${input.extraDefaults} more using defaults.`), input.ollama && parts.push(input.ollama), parts.length === 0 ? "Model catalogs refreshed." : parts.join(" ");
-}
-function formatLiveProviderError(provider) {
-  return provider.id === "xai" && provider.error && /invalid_grant|refresh token revoked/i.test(provider.error) && !/timed out|aborted|cancelled|ECONN|ENOTFOUND|network/i.test(provider.error) ? "xai login expired (run /login xai)" : provider.error ? `${provider.id} failed (${provider.error})` : `${provider.id} failed`;
-}
-function knownModelKeys(bakedIn, official, user) {
-  let keys = new Set(official);
-  for (let key of user)
-    keys.add(key);
-  for (let model of bakedIn)
-    keys.add(modelKey(model.provider, model.id));
-  return keys;
-}
-
-// packages/coding-agent/dist/core/grok-cli-auth.js
-var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
-import { chmodSync as chmodSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir } from "node:os";
-import { dirname as dirname3, join as join3 } from "node:path";
-var XAI_PROVIDER_ID = "xai", XAI_GROK_CLI_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828", REFRESH_SKEW_MS = 300 * 1e3, AUTH_FILE_WRITE_OPTIONS2 = { encoding: "utf-8", mode: 384 };
-function grokHomeDir(grokHome) {
-  if (grokHome)
-    return grokHome;
-  let fromEnv = process.env.GROK_HOME?.trim();
-  return fromEnv || join3(homedir(), ".grok");
-}
-function grokAuthPath(grokHome) {
-  return join3(grokHomeDir(grokHome), "auth.json");
-}
-function grokOidcEntryKey(clientId = XAI_GROK_CLI_CLIENT_ID) {
-  return `https://auth.x.ai::${clientId}`;
-}
-function parseGrokExpiresAt(value) {
-  if (typeof value == "number" && Number.isFinite(value) && value > 0)
-    return value < 1e12 ? Math.round(value * 1e3) : Math.round(value);
-  if (typeof value == "string" && value.trim()) {
-    let numeric = Number(value);
-    if (Number.isFinite(numeric) && numeric > 0)
-      return numeric < 1e12 ? Math.round(numeric * 1e3) : Math.round(numeric);
-    let parsed = Date.parse(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-}
-function formatGrokExpiresAt(expires) {
-  return new Date(expires).toISOString();
-}
-function grokEntryToOAuth(entry) {
-  if (!entry || typeof entry != "object" || Array.isArray(entry))
-    return;
-  let record = entry, access = typeof record.key == "string" ? record.key : void 0, refresh = typeof record.refresh_token == "string" ? record.refresh_token : void 0, expires = parseGrokExpiresAt(record.expires_at);
-  if (!(!access || !refresh || expires === void 0))
-    return { type: "oauth", access, refresh, expires };
-}
-function readGrokCliXaiOAuth(options = {}) {
-  try {
-    let raw = readFileSync3(grokAuthPath(options.grokHome), "utf-8"), parsed = JSON.parse(raw);
-    return !parsed || typeof parsed != "object" || Array.isArray(parsed) ? void 0 : grokEntryToOAuth(parsed[grokOidcEntryKey()]);
-  } catch {
-    return;
-  }
-}
-function hasGrokCliXaiAuth(options = {}) {
-  return readGrokCliXaiOAuth(options) !== void 0;
-}
-function chooseXaiOAuth(lunr, grok) {
-  if (lunr?.type === "api_key")
-    return lunr;
-  let lunrOAuth = lunr?.type === "oauth" ? lunr : void 0;
-  if (lunrOAuth && grok) {
-    if (lunrOAuth.refresh === grok.refresh)
-      return grok.expires >= lunrOAuth.expires ? grok : lunrOAuth;
-    let now = Date.now(), lunrLive = now < lunrOAuth.expires, grokLive = now < grok.expires;
-    return grokLive && !lunrLive ? grok : lunrLive && !grokLive ? lunrOAuth : !lunrLive && !grokLive && grok.expires >= lunrOAuth.expires ? grok : lunrOAuth;
-  }
-  return grok ?? lunrOAuth ?? lunr;
-}
-function oauthRefreshFailed(error) {
-  let parts = [], current = error, seen = /* @__PURE__ */ new Set();
-  for (; current && typeof current == "object" && !seen.has(current); ) {
-    if (seen.add(current), current instanceof Error) {
-      parts.push(current.message), current = current.cause;
-      continue;
-    }
-    break;
-  }
-  let chain = parts.join(" ");
-  return /timed out|aborted|cancelled|ECONN|ENOTFOUND|network/i.test(chain) ? !1 : /invalid_grant|refresh token revoked/i.test(chain);
-}
-function shouldAdopt(lunr, chosen) {
-  return !chosen || chosen.type !== "oauth" ? !1 : !lunr || lunr.type !== "oauth" ? !0 : lunr.access !== chosen.access || lunr.refresh !== chosen.refresh;
-}
-function writeAuthFileAtomic2(authPath, contents) {
-  let tmp = `${authPath}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync3(tmp, contents, AUTH_FILE_WRITE_OPTIONS2);
-  try {
-    chmodSync2(tmp, 384);
-  } catch {
-  }
-  try {
-    if (process.platform === "win32" && existsSync3(authPath)) {
-      writeFileSync3(authPath, contents, AUTH_FILE_WRITE_OPTIONS2), chmodSync2(authPath, 384);
-      return;
-    }
-    renameSync3(tmp, authPath);
-    try {
-      chmodSync2(authPath, 384);
-    } catch {
-    }
-  } finally {
-    try {
-      unlinkSync3(tmp);
-    } catch {
-    }
-  }
-}
-function acquireGrokLock(authPath) {
-  let lastError;
-  for (let attempt = 1; attempt <= 10; attempt++)
-    try {
-      return import_proper_lockfile2.default.lockSync(authPath, { realpath: !1, stale: 12e4 });
-    } catch (error) {
-      if ((typeof error == "object" && error !== null && "code" in error ? String(error.code) : void 0) !== "ELOCKED" || attempt === 10)
-        throw error;
-      lastError = error;
-      let start = Date.now();
-      for (; Date.now() - start < 20; )
-        ;
-    }
-  throw lastError ?? new Error("Failed to acquire Grok CLI auth lock");
-}
-function writeGrokCliXaiOAuth(credential, options = {}) {
-  let authPath = grokAuthPath(options.grokHome);
-  if (options.onlyIfFileExists !== !1 && !existsSync3(authPath))
-    return !1;
-  let dir = dirname3(authPath);
-  existsSync3(dir) || mkdirSync3(dir, { recursive: !0, mode: 448 }), existsSync3(authPath) || writeAuthFileAtomic2(authPath, `{}
-`);
-  let release;
-  try {
-    release = acquireGrokLock(authPath);
-    let data = {};
-    try {
-      let parsed = JSON.parse(readFileSync3(authPath, "utf-8"));
-      if (parsed && typeof parsed == "object" && !Array.isArray(parsed))
-        data = parsed;
-      else
-        return !1;
-    } catch {
-      return !1;
-    }
-    let key = grokOidcEntryKey(), previous = data[key] && typeof data[key] == "object" && !Array.isArray(data[key]) ? data[key] : {}, existing = grokEntryToOAuth(previous);
-    return existing && existing.refresh !== credential.refresh && existing.expires > credential.expires + REFRESH_SKEW_MS ? !1 : (data[key] = {
-      ...previous,
-      key: credential.access,
-      refresh_token: credential.refresh,
-      expires_at: formatGrokExpiresAt(credential.expires)
-    }, writeAuthFileAtomic2(authPath, `${JSON.stringify(data, null, 2)}
-`), !0);
-  } finally {
-    if (release)
-      try {
-        release();
-      } catch {
-      }
-  }
-}
-function wrapXaiGrokCliCredentials(store, options = {}) {
-  let grokHome = options.grokHome;
-  return {
-    async read(providerId) {
-      let stored = await store.read(providerId);
-      if (providerId !== XAI_PROVIDER_ID || stored?.type === "api_key")
-        return stored;
-      let grok = readGrokCliXaiOAuth({ grokHome }), chosen = chooseXaiOAuth(stored, grok);
-      if (shouldAdopt(stored, chosen) && chosen?.type === "oauth")
-        try {
-          await store.modify(providerId, async (current) => {
-            if (current?.type === "api_key")
-              return;
-            let latestGrok = readGrokCliXaiOAuth({ grokHome }), latestChosen = chooseXaiOAuth(current, latestGrok);
-            if (shouldAdopt(current, latestChosen) && latestChosen?.type === "oauth")
-              return latestChosen;
-          });
-        } catch {
-        }
-      return chosen;
-    },
-    async list() {
-      let entries = new Map((await store.list()).map((entry) => [entry.providerId, entry]));
-      return !entries.has(XAI_PROVIDER_ID) && hasGrokCliXaiAuth({ grokHome }) && entries.set(XAI_PROVIDER_ID, { providerId: XAI_PROVIDER_ID, type: "oauth" }), [...entries.values()];
-    },
-    modify(providerId, fn) {
-      return providerId !== XAI_PROVIDER_ID ? store.modify(providerId, fn) : store.modify(providerId, async (lunrCurrent) => {
-        if (lunrCurrent?.type === "api_key")
-          return fn(lunrCurrent);
-        let grok = readGrokCliXaiOAuth({ grokHome }), chosen = chooseXaiOAuth(lunrCurrent, grok), next;
-        try {
-          next = await fn(chosen);
-        } catch (error) {
-          let retryGrok = readGrokCliXaiOAuth({ grokHome });
-          if (!(oauthRefreshFailed(error) && retryGrok && !(chosen?.type === "oauth" && retryGrok.refresh === chosen.refresh)))
-            throw error;
-          try {
-            next = await fn(retryGrok);
-          } catch {
-            throw error;
-          }
-        }
-        if (next?.type === "oauth")
-          try {
-            writeGrokCliXaiOAuth(next, { grokHome, onlyIfFileExists: !0 });
-          } catch {
-          }
-        return next;
-      });
-    },
-    delete(providerId) {
-      return store.delete(providerId);
-    }
-  };
-}
-
-// packages/coding-agent/dist/core/live-catalog.js
-import { isOpenAiChatModel, parseOpenAiGptVersion } from "@ashx-j/lunr-ai";
-import { codexModelsUrl, resolveCodexCatalogVersion } from "@ashx-j/lunr-ai/catalog/codex";
-import { normalizeCatalogPricing } from "@ashx-j/lunr-ai/catalog/metadata";
-
-// packages/coding-agent/dist/core/codex-catalog.js
-import { parseCodexCatalog } from "@ashx-j/lunr-ai/catalog/codex";
-function discoverCodexModels(payload, baseUrl) {
-  return parseCodexCatalog(payload, baseUrl).map((model) => ({
-    model,
-    supplied: {
-      name: model.catalog.supplied.includes("name"),
-      contextWindow: model.catalog.supplied.includes("contextWindow"),
-      maxTokens: model.catalog.supplied.includes("maxTokens"),
-      input: model.catalog.supplied.includes("input"),
-      cost: !1,
-      reasoning: model.catalog.supplied.includes("reasoning")
-    }
-  }));
-}
-
-// packages/coding-agent/dist/core/live-catalog.js
-var LIVE_CATALOG_TIMEOUT_MS = 4e3;
-var DEFAULT_CONTEXT_WINDOW = 128e3, DEFAULT_MAX_TOKENS = 8192, LIVE_LIST_PROVIDER_IDS = [
-  "openai-codex",
-  "xai",
-  "openrouter",
-  "qwen-cloud",
-  "qwen-cloud-cn",
-  "groq",
-  "openai",
-  "deepseek"
-], LIVE_LIST_PROVIDER_SET = new Set(LIVE_LIST_PROVIDER_IDS);
-var ZERO_COST2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, NONE_SUPPLIED = {
-  contextWindow: !1,
-  maxTokens: !1,
-  input: !1,
-  name: !1,
-  cost: !1,
-  reasoning: !1
-};
-function isRecord2(value) {
-  return typeof value == "object" && value !== null && !Array.isArray(value);
-}
-function asFiniteNumber2(value) {
-  if (typeof value == "number" && Number.isFinite(value))
-    return value;
-  if (typeof value == "string" && value.trim()) {
-    let parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-}
-function roundCost(value) {
-  return Number(value.toFixed(6));
-}
-function modelsListUrl(baseUrl) {
-  return `${baseUrl.replace(/\/+$/u, "")}/models`;
-}
-function credentialAuthHeaders(credential) {
-  return credential ? credential.type === "api_key" && credential.key ? { Authorization: `Bearer ${credential.key}` } : credential.type === "oauth" && typeof credential.access == "string" && credential.access ? { Authorization: `Bearer ${credential.access}` } : {} : {};
-}
-function parseOpenAIModelsList(value) {
-  let entries = isRecord2(value) && Array.isArray(value.data) ? value.data : Array.isArray(value) ? value : [], rows = [];
-  for (let entry of entries) {
-    if (typeof entry == "string" && entry.trim()) {
-      rows.push({ id: entry.trim() });
-      continue;
-    }
-    isRecord2(entry) && typeof entry.id == "string" && entry.id.trim() && rows.push(entry);
-  }
-  return rows;
-}
-function firstBakedInModel(models) {
-  return models[0];
-}
-function selectLiveTemplate(providerId, id, bakedIn) {
-  let exact = bakedIn.find((model) => model.id === id);
-  if (exact)
-    return exact;
-  let version = parseOpenAiGptVersion(id);
-  if (providerId !== "openai" || !version || version.major < 5 || isOpenAiChatModel(id))
-    return firstBakedInModel(bakedIn);
-  let reasoning;
-  for (let model of bakedIn)
-    model.reasoning && parseOpenAiGptVersion(model.id) && (reasoning = model);
-  return reasoning ?? firstBakedInModel(bakedIn);
-}
-function uniqueApis(models) {
-  let seen = /* @__PURE__ */ new Set(), apis = [];
-  for (let model of models)
-    seen.has(model.api) || (seen.add(model.api), apis.push(model.api));
-  return apis;
-}
-function synthesizeLiveModel(id, template, raw = {}) {
-  let name = typeof raw.name == "string" && raw.name.trim() ? raw.name.trim() : id, exact = id === template.id, discovery = {
-    model: {
-      id,
-      name,
-      api: template.api,
-      provider: template.provider,
-      baseUrl: template.baseUrl,
-      reasoning: template.reasoning,
-      input: exact ? template.input : ["text"],
-      cost: ZERO_COST2,
-      contextWindow: DEFAULT_CONTEXT_WINDOW,
-      maxTokens: DEFAULT_MAX_TOKENS,
-      compat: template.compat,
-      thinkingLevelMap: exact ? template.thinkingLevelMap : void 0,
-      catalog: { source: "provider", supplied: typeof raw.name == "string" ? ["name"] : [], pricing: "unknown" }
-    },
-    supplied: {
-      ...NONE_SUPPLIED,
-      name: typeof raw.name == "string" && raw.name.trim().length > 0
-    }
-  }, context = asFiniteNumber2(raw.context_window ?? raw.context_length ?? raw.max_context_length), output = asFiniteNumber2(raw.max_output_tokens ?? raw.max_completion_tokens);
-  if (context && context > 0 && (discovery.model.contextWindow = context, discovery.supplied.contextWindow = !0), output && output > 0 && (discovery.model.maxTokens = output, discovery.supplied.maxTokens = !0), typeof raw.reasoning == "boolean" && (discovery.model.reasoning = raw.reasoning, discovery.supplied.reasoning = !0), Array.isArray(raw.input_modalities)) {
-    let input = raw.input_modalities.filter((value) => value === "text" || value === "image");
-    input.length && (discovery.model.input = input, discovery.supplied.input = !0);
-  }
-  return discovery.model.catalog.supplied = Object.entries(discovery.supplied).filter(([, value]) => value).map(([field]) => field), discovery;
-}
-function mapOpenRouterModel(raw, template) {
-  let id = typeof raw.id == "string" ? raw.id.trim() : "";
-  if (!id)
-    return;
-  let supported = Array.isArray(raw.supported_parameters) ? raw.supported_parameters : [];
-  if (!supported.includes("tools"))
-    return;
-  let architecture = isRecord2(raw.architecture) ? raw.architecture : void 0, modality = typeof architecture?.modality == "string" ? architecture.modality : "", input = ["text"];
-  modality.includes("image") && input.push("image");
-  let pricing = isRecord2(raw.pricing) ? raw.pricing : void 0, inputCost = roundCost((asFiniteNumber2(pricing?.prompt) ?? 0) * 1e6), outputCost = roundCost((asFiniteNumber2(pricing?.completion) ?? 0) * 1e6), cacheReadCost = roundCost((asFiniteNumber2(pricing?.input_cache_read) ?? 0) * 1e6), cacheWriteCost = roundCost((asFiniteNumber2(pricing?.input_cache_write) ?? 0) * 1e6), topProvider = isRecord2(raw.top_provider) ? raw.top_provider : void 0, contextWindow = asFiniteNumber2(topProvider?.context_length) ?? asFiniteNumber2(raw.context_length), maxTokens = asFiniteNumber2(topProvider?.max_completion_tokens) ?? asFiniteNumber2(raw.max_completion_tokens), name = typeof raw.name == "string" && raw.name.trim() ? raw.name.trim() : id;
-  return {
-    model: {
-      id,
-      name,
-      api: template.api,
-      provider: template.provider,
-      baseUrl: template.baseUrl,
-      reasoning: supported.includes("reasoning") || template.reasoning,
-      input,
-      cost: {
-        input: inputCost,
-        output: outputCost,
-        cacheRead: cacheReadCost,
-        cacheWrite: cacheWriteCost
-      },
-      contextWindow: contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-      maxTokens: maxTokens ?? DEFAULT_MAX_TOKENS,
-      compat: template.compat,
-      thinkingLevelMap: template.thinkingLevelMap
-    },
-    supplied: {
-      contextWindow: contextWindow !== void 0,
-      maxTokens: maxTokens !== void 0,
-      input: !0,
-      name: typeof raw.name == "string" && raw.name.trim().length > 0,
-      cost: asFiniteNumber2(pricing?.prompt) !== void 0 && asFiniteNumber2(pricing?.completion) !== void 0,
-      reasoning: supported.includes("reasoning")
-    }
-  };
-}
-function discoverLiveModels(providerId, payload, bakedIn) {
-  if (providerId === "openai-codex")
-    return discoverCodexModels(payload, bakedIn[0]?.baseUrl ?? "https://chatgpt.com/backend-api");
-  let fallback = firstBakedInModel(bakedIn);
-  if (!fallback)
-    return [];
-  let rows = parseOpenAIModelsList(payload), discoveries = [];
-  for (let raw of rows) {
-    let id = typeof raw.id == "string" ? raw.id.trim() : "";
-    if (!id || raw.tool_call === !1 || raw.type === "embedding" || providerId === "openai" && /^(?:text-embedding-|tts-|whisper-|dall-e-|gpt-image-|gpt-audio|gpt-realtime|sora-|.*moderation)/i.test(id))
-      continue;
-    let template = { ...selectLiveTemplate(providerId, id, bakedIn) ?? fallback, provider: providerId };
-    if (providerId === "openrouter") {
-      let mapped = mapOpenRouterModel(raw, template);
-      mapped && (mapped.model.catalog = {
-        source: "provider",
-        ...mapped.supplied.cost ? {} : { pricing: "unknown" },
-        supplied: Object.entries(mapped.supplied).filter(([, supplied]) => supplied).map(([key]) => key)
-      }, mapped.model = normalizeCatalogPricing(mapped.model), mapped.model.catalog?.pricing === "unknown" && (mapped.supplied.cost = !1), discoveries.push(mapped));
-      continue;
-    }
-    discoveries.push(synthesizeLiveModel(id, template, raw));
-  }
-  return discoveries;
-}
-function missingLiveFields(supplied) {
-  let missing = [];
-  return supplied.contextWindow || missing.push("contextWindow"), supplied.maxTokens || missing.push("maxTokens"), supplied.input || missing.push("input"), missing;
-}
-function isLiveModelIncomplete(discovery, knownKeys) {
-  return knownKeys.has(modelKey(discovery.model.provider, discovery.model.id)) ? !1 : missingLiveFields(discovery.supplied).length > 0;
-}
-function collectIncompleteLiveModels(discoveries, bakedIn, knownKeys) {
-  let apis = uniqueApis(bakedIn), incomplete = [];
-  for (let discovery of discoveries)
-    isLiveModelIncomplete(discovery, knownKeys) && incomplete.push({
-      provider: discovery.model.provider,
-      id: discovery.model.id,
-      name: discovery.model.name,
-      missing: missingLiveFields(discovery.supplied),
-      draft: discovery.model,
-      availableApis: apis
-    });
-  return incomplete;
-}
-function buildLiveOverlay(bakedIn, discoveries) {
-  let bakedById = new Map(bakedIn.map((model) => [model.id, model])), overlay = [];
-  for (let discovery of discoveries) {
-    let baked = bakedById.get(discovery.model.id);
-    if (!baked) {
-      overlay.push(discovery.model);
-      continue;
-    }
-    overlay.push({
-      ...baked,
-      catalog: discovery.model.catalog,
-      thinkingLevelMap: discovery.model.catalog?.supplied.includes("thinkingLevelMap") ? discovery.model.thinkingLevelMap : baked.thinkingLevelMap,
-      name: discovery.supplied.name ? discovery.model.name : baked.name,
-      contextWindow: discovery.supplied.contextWindow ? discovery.model.contextWindow : baked.contextWindow,
-      maxTokens: discovery.supplied.maxTokens ? discovery.model.maxTokens : baked.maxTokens,
-      input: discovery.supplied.input ? discovery.model.input : baked.input,
-      cost: discovery.supplied.cost ? discovery.model.cost : baked.cost,
-      reasoning: discovery.supplied.reasoning ? discovery.model.reasoning : baked.reasoning
-    });
-  }
-  return overlay;
-}
-async function fetchLiveProviderModels(options) {
-  let empty = {
-    providerId: options.providerId,
-    status: "skipped",
-    discoveries: [],
-    added: 0,
-    total: 0,
-    incomplete: []
-  };
-  if (!firstBakedInModel(options.bakedIn) && options.providerId !== "openai-codex" || !options.baseUrl)
-    return empty;
-  let timeoutMs = options.timeoutMs ?? LIVE_CATALOG_TIMEOUT_MS, controller = new AbortController(), timedOut = !1, timer = setTimeout(() => {
-    timedOut = !0, controller.abort();
-  }, timeoutMs), onParentAbort = () => controller.abort();
-  options.signal?.addEventListener("abort", onParentAbort, { once: !0 }), options.signal?.aborted && controller.abort();
-  try {
-    let fetchImpl = options.fetchImpl ?? fetch, codex = options.providerId === "openai-codex", accountId = options.credential?.type === "oauth" && typeof options.credential.accountId == "string" ? options.credential.accountId : void 0, discoveryClientVersion = options.discoveryClientVersion, payload = await Promise.race([
-      (async () => {
-        codex && (discoveryClientVersion = await resolveCodexCatalogVersion(fetchImpl, controller.signal, discoveryClientVersion));
-        let response = await fetchImpl(codex ? codexModelsUrl(options.baseUrl, discoveryClientVersion) : modelsListUrl(options.baseUrl), {
-          headers: {
-            accept: "application/json",
-            "User-Agent": getPiUserAgent(VERSION),
-            ...credentialAuthHeaders(options.credential),
-            ...accountId ? { "ChatGPT-Account-ID": accountId } : {}
-          },
-          signal: controller.signal
-        });
-        if (!response.ok)
-          throw new Error(`HTTP ${response.status}`);
-        return response.json();
-      })(),
-      new Promise((_, reject) => {
-        let abortError = new Error("The operation was aborted");
-        abortError.name = "AbortError", controller.signal.addEventListener("abort", () => reject(abortError), { once: !0 }), controller.signal.aborted && reject(abortError);
-      })
-    ]), discoveries = codex ? discoverCodexModels(payload, options.baseUrl) : discoverLiveModels(options.providerId, payload, options.bakedIn);
-    if (!discoveries.length)
-      throw new Error("No usable models returned; retaining cached models");
-    let bakedIds = new Set(options.bakedIn.map((model) => model.id)), added = discoveries.filter((discovery) => !bakedIds.has(discovery.model.id)).length;
-    return {
-      providerId: options.providerId,
-      discoveryClientVersion,
-      status: "ok",
-      discoveries,
-      added,
-      total: discoveries.length,
-      incomplete: collectIncompleteLiveModels(discoveries, options.bakedIn, options.knownKeys)
-    };
-  } catch (error) {
-    return options.signal?.aborted && !timedOut ? { ...empty, status: "skipped", error: "aborted" } : timedOut || error instanceof Error && error.name === "AbortError" ? { ...empty, status: "timeout", error: "timed out" } : {
-      ...empty,
-      status: "error",
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timer), options.signal?.removeEventListener("abort", onParentAbort);
-  }
-}
-
-// packages/coding-agent/dist/core/model-config.js
-import { readFile } from "node:fs/promises";
-import { Type } from "typebox";
-import { Compile } from "typebox/compile";
-
-// packages/coding-agent/dist/utils/json.js
-function stripJsonComments(input) {
-  return input.replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => m[0] === '"' ? m : "").replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === '"' ? m : ""));
-}
-
-// packages/coding-agent/dist/core/model-config.js
-var PercentileCutoffsSchema = Type.Object({
-  p50: Type.Optional(Type.Number()),
-  p75: Type.Optional(Type.Number()),
-  p90: Type.Optional(Type.Number()),
-  p99: Type.Optional(Type.Number())
-}), OpenRouterRoutingSchema = Type.Object({
-  allow_fallbacks: Type.Optional(Type.Boolean()),
-  require_parameters: Type.Optional(Type.Boolean()),
-  data_collection: Type.Optional(Type.Union([Type.Literal("deny"), Type.Literal("allow")])),
-  zdr: Type.Optional(Type.Boolean()),
-  enforce_distillable_text: Type.Optional(Type.Boolean()),
-  order: Type.Optional(Type.Array(Type.String())),
-  only: Type.Optional(Type.Array(Type.String())),
-  ignore: Type.Optional(Type.Array(Type.String())),
-  quantizations: Type.Optional(Type.Array(Type.String())),
-  sort: Type.Optional(Type.Union([
-    Type.String(),
-    Type.Object({
-      by: Type.Optional(Type.String()),
-      partition: Type.Optional(Type.Union([Type.String(), Type.Null()]))
-    })
-  ])),
-  max_price: Type.Optional(Type.Object({
-    prompt: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    completion: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    image: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    audio: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    request: Type.Optional(Type.Union([Type.Number(), Type.String()]))
-  })),
-  preferred_min_throughput: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema])),
-  preferred_max_latency: Type.Optional(Type.Union([Type.Number(), PercentileCutoffsSchema]))
-}), VercelGatewayRoutingSchema = Type.Object({
-  only: Type.Optional(Type.Array(Type.String())),
-  order: Type.Optional(Type.Array(Type.String()))
-}), ThinkingLevelMapValueSchema = Type.Union([Type.String(), Type.Null()]), ThinkingLevelMapSchema = Type.Object({
-  off: Type.Optional(ThinkingLevelMapValueSchema),
-  minimal: Type.Optional(ThinkingLevelMapValueSchema),
-  low: Type.Optional(ThinkingLevelMapValueSchema),
-  medium: Type.Optional(ThinkingLevelMapValueSchema),
-  high: Type.Optional(ThinkingLevelMapValueSchema),
-  xhigh: Type.Optional(ThinkingLevelMapValueSchema),
-  max: Type.Optional(ThinkingLevelMapValueSchema)
-}), ChatTemplateKwargScalarSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]), ChatTemplateKwargVariableSchema = Type.Object({
-  $var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
-  omitWhenOff: Type.Optional(Type.Boolean())
-}), ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]), OpenAICompletionsCompatSchema = Type.Object({
-  supportsStore: Type.Optional(Type.Boolean()),
-  supportsDeveloperRole: Type.Optional(Type.Boolean()),
-  supportsReasoningEffort: Type.Optional(Type.Boolean()),
-  supportsUsageInStreaming: Type.Optional(Type.Boolean()),
-  maxTokensField: Type.Optional(Type.Union([Type.Literal("max_completion_tokens"), Type.Literal("max_tokens")])),
-  requiresToolResultName: Type.Optional(Type.Boolean()),
-  requiresAssistantAfterToolResult: Type.Optional(Type.Boolean()),
-  requiresThinkingAsText: Type.Optional(Type.Boolean()),
-  requiresReasoningContentOnAssistantMessages: Type.Optional(Type.Boolean()),
-  thinkingFormat: Type.Optional(Type.Union([
-    Type.Literal("openai"),
-    Type.Literal("openrouter"),
-    Type.Literal("together"),
-    Type.Literal("deepseek"),
-    Type.Literal("zai"),
-    Type.Literal("qwen"),
-    Type.Literal("chat-template"),
-    Type.Literal("qwen-chat-template"),
-    Type.Literal("string-thinking"),
-    Type.Literal("ant-ling")
-  ])),
-  chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
-  cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
-  openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
-  vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
-  supportsStrictMode: Type.Optional(Type.Boolean()),
-  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
-  deferredToolsMode: Type.Optional(Type.Literal("kimi")),
-  sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
-  supportsLongCacheRetention: Type.Optional(Type.Boolean())
-}), OpenAIResponsesCompatSchema = Type.Object({
-  supportsDeveloperRole: Type.Optional(Type.Boolean()),
-  sessionAffinityFormat: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("openai-nosession"), Type.Literal("openrouter")])),
-  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
-  supportsToolSearch: Type.Optional(Type.Boolean())
-}), AnthropicMessagesCompatSchema = Type.Object({
-  supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
-  supportsLongCacheRetention: Type.Optional(Type.Boolean()),
-  sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
-  supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
-  forceAdaptiveThinking: Type.Optional(Type.Boolean()),
-  supportsToolReferences: Type.Optional(Type.Boolean())
-}), ProviderCompatSchema = Type.Union([
-  OpenAICompletionsCompatSchema,
-  OpenAIResponsesCompatSchema,
-  AnthropicMessagesCompatSchema
-]), ModelCostRatesSchema = {
-  input: Type.Number(),
-  output: Type.Number(),
-  cacheRead: Type.Number(),
-  cacheWrite: Type.Number()
-}, ModelCostTierSchema = Type.Object({
-  inputTokensAbove: Type.Number(),
-  ...ModelCostRatesSchema
-}), ModelCostSchema = Type.Object({
-  ...ModelCostRatesSchema,
-  tiers: Type.Optional(Type.Array(ModelCostTierSchema))
-}), ModelDefinitionSchema = Type.Object({
-  id: Type.String({ minLength: 1 }),
-  name: Type.Optional(Type.String({ minLength: 1 })),
-  api: Type.Optional(Type.String({ minLength: 1 })),
-  baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-  reasoning: Type.Optional(Type.Boolean()),
-  thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
-  input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-  cost: Type.Optional(ModelCostSchema),
-  contextWindow: Type.Optional(Type.Number()),
-  maxTokens: Type.Optional(Type.Number()),
-  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-  compat: Type.Optional(ProviderCompatSchema)
-}), ModelOverrideSchema = Type.Object({
-  name: Type.Optional(Type.String({ minLength: 1 })),
-  reasoning: Type.Optional(Type.Boolean()),
-  thinkingLevelMap: Type.Optional(ThinkingLevelMapSchema),
-  input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
-  cost: Type.Optional(Type.Object({
-    input: Type.Optional(Type.Number()),
-    output: Type.Optional(Type.Number()),
-    cacheRead: Type.Optional(Type.Number()),
-    cacheWrite: Type.Optional(Type.Number()),
-    tiers: Type.Optional(Type.Array(ModelCostTierSchema))
-  })),
-  contextWindow: Type.Optional(Type.Number()),
-  maxTokens: Type.Optional(Type.Number()),
-  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-  compat: Type.Optional(ProviderCompatSchema)
-}), ProviderConfigSchema = Type.Object({
-  name: Type.Optional(Type.String({ minLength: 1 })),
-  baseUrl: Type.Optional(Type.String({ minLength: 1 })),
-  apiKey: Type.Optional(Type.String({ minLength: 1 })),
-  api: Type.Optional(Type.String({ minLength: 1 })),
-  oauth: Type.Optional(Type.Literal("radius")),
-  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-  compat: Type.Optional(ProviderCompatSchema),
-  authHeader: Type.Optional(Type.Boolean()),
-  models: Type.Optional(Type.Array(ModelDefinitionSchema)),
-  modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema))
-}), ModelsConfigSchema = Type.Object({
-  providers: Type.Record(Type.String(), ProviderConfigSchema)
-}), validateModelsConfig = Compile(ModelsConfigSchema);
-function formatValidationPath(error) {
-  if (error.keyword === "required") {
-    let requiredProperty = error.params.requiredProperties?.[0];
-    if (requiredProperty) {
-      let basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
-      return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
-    }
-  }
-  return error.instancePath.replace(/^\//, "").replace(/\//g, ".") || "root";
-}
-function deepFreeze(value) {
-  if (typeof value != "object" || value === null || Object.isFrozen(value))
-    return value;
-  for (let child of Object.values(value))
-    deepFreeze(child);
-  return Object.freeze(value);
-}
-var ModelConfig = class _ModelConfig {
-  providers;
-  error;
-  constructor(providers, error) {
-    this.providers = providers, this.error = error;
-  }
-  static async load(modelsJsonPath) {
-    if (!modelsJsonPath)
-      return new _ModelConfig(/* @__PURE__ */ new Map());
-    let path = normalizePath(modelsJsonPath), content;
-    try {
-      content = await readFile(path, "utf-8");
-    } catch (error) {
-      return error.code === "ENOENT" ? new _ModelConfig(/* @__PURE__ */ new Map()) : new _ModelConfig(/* @__PURE__ */ new Map(), `Failed to load models.json: ${error instanceof Error ? error.message : error}
-
-File: ${path}`);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(stripJsonComments(content));
-    } catch (error) {
-      return new _ModelConfig(/* @__PURE__ */ new Map(), `Failed to parse models.json: ${error instanceof Error ? error.message : error}
-
-File: ${path}`);
-    }
-    if (!validateModelsConfig.Check(parsed)) {
-      let errors = validateModelsConfig.Errors(parsed).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join(`
-`) || "Unknown schema error";
-      return new _ModelConfig(/* @__PURE__ */ new Map(), `Invalid models.json schema:
-${errors}
-
-File: ${path}`);
-    }
-    let config = parsed, providers = /* @__PURE__ */ new Map();
-    for (let [providerId, provider] of Object.entries(config.providers))
-      providers.set(providerId, deepFreeze(structuredClone(provider)));
-    return new _ModelConfig(providers);
-  }
-  getProvider(providerId) {
-    return this.providers.get(providerId);
-  }
-  getProviderIds() {
-    return [...this.providers.keys()];
-  }
-  getError() {
-    return this.error;
-  }
-};
-
-// packages/coding-agent/dist/core/models-store.js
-import { join as join4 } from "node:path";
-var InMemoryCodingAgentModelsStore = class {
-  entries = /* @__PURE__ */ new Map();
-  async read(providerId) {
-    return this.entries.get(providerId);
-  }
-  async write(providerId, entry) {
-    this.entries.set(providerId, entry);
-  }
-  async delete(providerId) {
-    this.entries.delete(providerId);
-  }
-}, FileModelsStore = class {
-  storage;
-  constructor(path = join4(getAgentDir(), "models-store.json")) {
-    this.storage = new FileAuthStorageBackend(path);
-  }
-  parse(content) {
-    let trimmed = content?.replace(/^\uFEFF/, "").trim();
-    if (!trimmed)
-      return {};
-    try {
-      let parsed = JSON.parse(trimmed);
-      return !parsed || typeof parsed != "object" || Array.isArray(parsed) ? {} : parsed;
-    } catch {
-      return {};
-    }
-  }
-  async read(providerId) {
-    return this.storage.withLock((content) => ({
-      result: structuredClone(this.parse(content)[providerId])
-    }));
-  }
-  async write(providerId, entry) {
-    await this.storage.withLockAsync(async (content) => {
-      let current = this.parse(content);
-      return current[providerId] = structuredClone(entry), { result: void 0, next: JSON.stringify(current, null, 2) };
-    });
-  }
-  async delete(providerId) {
-    await this.storage.withLockAsync(async (content) => {
-      let current = this.parse(content);
-      return delete current[providerId], { result: void 0, next: JSON.stringify(current, null, 2) };
-    });
-  }
-};
-
-// packages/coding-agent/dist/core/provider-composer.js
-import { lazyStream } from "@ashx-j/lunr-ai";
-import { getApiProvider } from "@ashx-j/lunr-ai/compat";
-function mergeCompat(base, override) {
-  if (!override)
-    return base;
-  let merged = { ...base, ...override }, baseNested = base, overrideNested = override, mergedNested = merged;
-  for (let key of ["openRouterRouting", "vercelGatewayRouting", "chatTemplateKwargs"]) {
-    let baseValue = baseNested?.[key], overrideValue = overrideNested[key];
-    (typeof baseValue == "object" && baseValue !== null || typeof overrideValue == "object" && overrideValue !== null) && (mergedNested[key] = { ...baseValue, ...overrideValue });
-  }
-  return merged;
-}
-function applyModelOverride(model, override) {
-  return {
-    ...model,
-    name: override.name ?? model.name,
-    reasoning: override.reasoning ?? model.reasoning,
-    thinkingLevelMap: override.thinkingLevelMap ? { ...model.thinkingLevelMap, ...override.thinkingLevelMap } : model.thinkingLevelMap,
-    input: override.input ?? model.input,
-    cost: override.cost ? {
-      input: override.cost.input ?? model.cost.input,
-      output: override.cost.output ?? model.cost.output,
-      cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
-      cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
-      tiers: override.cost.tiers ?? model.cost.tiers
-    } : model.cost,
-    contextWindow: override.contextWindow ?? model.contextWindow,
-    maxTokens: override.maxTokens ?? model.maxTokens,
-    compat: mergeCompat(model.compat, override.compat)
-  };
-}
-function modelFromJson(providerId, definition, providerConfig, defaults) {
-  let api = definition.api ?? providerConfig.api ?? defaults?.api;
-  if (!api)
-    throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
-  let baseUrl = definition.baseUrl ?? providerConfig.baseUrl ?? defaults?.baseUrl;
-  if (!baseUrl)
-    throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
-  if (definition.contextWindow !== void 0 && definition.contextWindow <= 0)
-    throw new Error(`Provider ${providerId}, model ${definition.id}: invalid contextWindow`);
-  if (definition.maxTokens !== void 0 && definition.maxTokens <= 0)
-    throw new Error(`Provider ${providerId}, model ${definition.id}: invalid maxTokens`);
-  return {
-    id: definition.id,
-    name: definition.name ?? definition.id,
-    api,
-    provider: providerId,
-    baseUrl,
-    reasoning: definition.reasoning ?? !1,
-    thinkingLevelMap: definition.thinkingLevelMap,
-    input: definition.input ?? ["text"],
-    cost: definition.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: definition.contextWindow ?? 128e3,
-    maxTokens: definition.maxTokens ?? 16384,
-    headers: void 0,
-    compat: mergeCompat(providerConfig.compat, definition.compat)
-  };
-}
-function applyModelsJson(providerId, baseModels, config) {
-  if (!config)
-    return [...baseModels];
-  if (config.oauth && !config.baseUrl)
-    throw new Error(`Provider ${providerId}: "baseUrl" is required when "oauth" is set.`);
-  let hasOverrides = config.modelOverrides && Object.keys(config.modelOverrides).length > 0;
-  if (!config.models?.length && !config.baseUrl && !config.headers && !config.compat && !hasOverrides && !config.apiKey && !config.oauth && config.authHeader === void 0)
-    throw new Error(`Provider ${providerId}: must specify "baseUrl", "headers", "compat", "modelOverrides", or "models".`);
-  let models = baseModels.map((model) => ({
-    ...model,
-    baseUrl: config.oauth === "radius" ? model.baseUrl : config.baseUrl ?? model.baseUrl,
-    compat: mergeCompat(model.compat, config.compat)
-  }));
-  for (let definition of config.models ?? []) {
-    let existingIndex = models.findIndex((model2) => model2.id === definition.id), defaults = existingIndex >= 0 ? models[existingIndex] : models[0], model = modelFromJson(providerId, definition, config, defaults);
-    existingIndex >= 0 ? models[existingIndex] = model : models.push(model);
-  }
-  return models;
-}
-function applyExtension(providerId, models, config) {
-  return config ? config.models ? config.models.map((definition) => {
-    let defaults = models.find((model) => model.id === definition.id) ?? models[0], api = definition.api ?? config.api ?? defaults?.api;
-    if (!api)
-      throw new Error(`Provider ${providerId}, model ${definition.id}: no "api" specified. Set at provider or model level.`);
-    let baseUrl = definition.baseUrl ?? config.baseUrl ?? defaults?.baseUrl;
-    if (!baseUrl)
-      throw new Error(`Provider ${providerId}: "baseUrl" is required when defining custom models.`);
-    return {
-      ...definition,
-      api,
-      provider: providerId,
-      baseUrl,
-      headers: void 0
-    };
-  }) : config.baseUrl ? models.map((model) => ({ ...model, baseUrl: config.baseUrl })) : [...models] : [...models];
-}
-function adaptOAuth(config) {
-  return {
-    name: config.name,
-    login: async (callbacks) => ({ ...await config.login({
-      onAuth: (info) => callbacks.notify({ type: "auth_url", ...info }),
-      onDeviceCode: (info) => callbacks.notify({ type: "device_code", ...info }),
-      onPrompt: (prompt) => callbacks.prompt({ type: "text", ...prompt }),
-      onProgress: (message) => callbacks.notify({ type: "progress", message }),
-      onManualCodeInput: () => callbacks.prompt({ type: "manual_code", message: "Paste the authorization code" }),
-      onSelect: (prompt) => callbacks.prompt({ type: "select", ...prompt }),
-      signal: callbacks.signal
-    }), type: "oauth" }),
-    refresh: async (credential) => ({ ...await config.refreshToken(credential), type: "oauth" }),
-    toAuth: async (credential) => ({ apiKey: config.getApiKey(credential) })
-  };
-}
-function withConfiguredAuth(auth, headers, authHeader) {
-  let mergedHeaders = auth.headers || headers ? { ...auth.headers, ...headers } : void 0;
-  if (authHeader) {
-    if (!auth.apiKey)
-      throw new Error("authHeader requires a resolved API key");
-    mergedHeaders = { ...mergedHeaders, Authorization: `Bearer ${auth.apiKey}` };
-  }
-  return { ...auth, headers: mergedHeaders };
-}
-function configuredApiKey(config, extension) {
-  return extension?.apiKey ?? config?.apiKey;
-}
-function configuredHeaders(config, extension) {
-  if (!(!config?.headers && !extension?.headers))
-    return { ...config?.headers, ...extension?.headers };
-}
-async function configContextEnv(values, ctx, explicit) {
-  let env = { ...explicit };
-  for (let name of new Set(values.flatMap(getConfigValueEnvVarNames))) {
-    if (env[name] !== void 0)
-      continue;
-    let value = await ctx.env(name);
-    value !== void 0 && (env[name] = value);
-  }
-  return Object.keys(env).length > 0 ? env : void 0;
-}
-function composeApiKeyAuth(providerId, base, config, extension) {
-  let inherited = base?.auth.apiKey, rawKey = configuredApiKey(config, extension), oauth = extension?.oauth ?? base?.auth.oauth;
-  if (!inherited && rawKey === void 0 && oauth)
-    return;
-  let rawHeaders = configuredHeaders(config, extension), authHeader = extension?.authHeader ?? config?.authHeader ?? !1;
-  return {
-    name: inherited?.name ?? "API key",
-    login: inherited?.login ?? (async (interaction) => ({
-      type: "api_key",
-      key: await interaction.prompt({ type: "secret", message: "Enter API key" })
-    })),
-    check: async (input) => {
-      if (input.credential) {
-        if (inherited?.check)
-          return inherited.check(input);
-        if (input.credential.key)
-          return { type: "api_key", source: "stored credential" };
-        let resolved2 = await inherited?.resolve(input);
-        return resolved2 ? { type: "api_key", source: resolved2.source } : void 0;
-      }
-      if (rawKey !== void 0) {
-        if (isCommandConfigValue(rawKey))
-          return { type: "api_key", source: "configured API key" };
-        let envNames = getConfigValueEnvVarNames(rawKey);
-        for (let name of envNames)
-          if (await input.ctx.env(name) === void 0)
-            return;
-        return { type: "api_key", source: "configured API key" };
-      }
-      if (inherited?.check)
-        return inherited.check(input);
-      let resolved = await inherited?.resolve(input);
-      return resolved ? { type: "api_key", source: resolved.source } : void 0;
-    },
-    resolve: async (input) => {
-      let result;
-      if (input.credential)
-        result = inherited ? await inherited.resolve(input) : input.credential.key ? { auth: { apiKey: input.credential.key }, env: input.credential.env, source: "stored credential" } : void 0;
-      else if (rawKey !== void 0) {
-        let env = await configContextEnv([rawKey], input.ctx), key = resolveConfigValueOrThrow(rawKey, `API key for provider "${providerId}"`, env);
-        result = inherited ? await inherited.resolve({ ...input, credential: { type: "api_key", key } }) : { auth: { apiKey: key }, source: "configured API key" };
-      } else
-        result = await inherited?.resolve(input);
-      if (!result)
-        return;
-      let explicitEnv = { ...input.credential?.env ?? {}, ...result.env ?? {} }, headerEnv = await configContextEnv(Object.values(rawHeaders ?? {}), input.ctx, explicitEnv), headers = resolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, headerEnv);
-      return { ...result, auth: withConfiguredAuth(result.auth, headers, authHeader) };
-    }
-  };
-}
-function composeOAuthAuth(providerId, base, config, extension) {
-  let oauth = extension?.oauth ? adaptOAuth(extension.oauth) : base?.auth.oauth;
-  if (!oauth)
-    return;
-  let rawHeaders = configuredHeaders(config, extension), authHeader = extension?.authHeader ?? config?.authHeader ?? !1;
-  return {
-    ...oauth,
-    toAuth: async (credential) => {
-      let auth = await oauth.toAuth(credential), env = credential.env, headers = resolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, typeof env == "object" && env !== null ? env : void 0);
-      return withConfiguredAuth(auth, headers, authHeader);
-    }
-  };
-}
-function rawModelHeaders(model, config, extension) {
-  let definition = config?.models?.find((entry) => entry.id === model.id), extensionModel = extension?.models?.find((entry) => entry.id === model.id), headers = {
-    ...config?.modelOverrides?.[model.id]?.headers,
-    ...definition?.headers,
-    ...extensionModel?.headers
-  };
-  return Object.keys(headers).length > 0 ? headers : void 0;
-}
-function validateExtensionProvider(providerId, base, modelsConfig, extension) {
-  if (extension.streamSimple && !extension.api)
-    throw new Error(`Provider ${providerId}: "api" is required when registering streamSimple.`);
-  applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], modelsConfig), extension);
-}
-function composeModelProvider(providerId, base, modelConfig, extension) {
-  let config = modelConfig.getProvider(providerId), extensionOAuthCredential, refreshedExtensionModels, currentExtension = () => extension && refreshedExtensionModels ? { ...extension, models: refreshedExtensionModels } : extension, getModels = () => {
-    let models = applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), currentExtension());
-    return extensionOAuthCredential && extension?.oauth?.modifyModels && (models = extension.oauth.modifyModels(models, extensionOAuthCredential)), models.map((model) => {
-      let override = config?.modelOverrides?.[model.id];
-      return override ? applyModelOverride(model, override) : model;
-    });
-  };
-  getModels();
-  let apiKey = composeApiKeyAuth(providerId, base, config, extension), oauth = composeOAuthAuth(providerId, base, config, extension);
-  if (!apiKey && !oauth)
-    throw new Error(`Provider ${providerId}: no authentication method configured.`);
-  let supportsBaseApi = (model) => base?.getModels().some((entry) => entry.api === model.api) ?? !1, streamWith = (model, context, options, simple) => lazyStream(model, async () => {
-    if (extension?.streamSimple && model.api === extension.api)
-      return extension.streamSimple(model, context, options);
-    if (base && supportsBaseApi(model))
-      return simple ? base.streamSimple(model, context, options) : base.stream(model, context, options);
-    let api = getApiProvider(model.api);
-    if (!api)
-      throw new Error(`No API provider registered for api: ${model.api}`);
-    return simple ? api.streamSimple(model, context, options) : api.stream(model, context, options);
-  });
-  return {
-    id: providerId,
-    name: extension?.name ?? config?.name ?? base?.name ?? extension?.oauth?.name ?? providerId,
-    baseUrl: extension?.baseUrl ?? config?.baseUrl ?? base?.baseUrl,
-    headers: base?.headers,
-    auth: { ...apiKey ? { apiKey } : {}, ...oauth ? { oauth } : {} },
-    getModels,
-    refreshModels: base?.refreshModels || extension?.refreshModels || extension?.oauth?.modifyModels ? async (context) => {
-      if (await base?.refreshModels?.(context), extension?.refreshModels) {
-        let refreshed = await extension.refreshModels(context);
-        context.signal?.aborted || (applyExtension(providerId, applyModelsJson(providerId, base?.getModels() ?? [], config), {
-          ...extension,
-          models: refreshed
-        }), refreshedExtensionModels = refreshed);
-      }
-      extensionOAuthCredential = context.credential?.type === "oauth" ? context.credential : void 0;
-    } : void 0,
-    filterModels: base?.filterModels ? (models, credential) => base.filterModels(models, credential) : void 0,
-    stream: (model, context, options) => streamWith(model, context, options, !1),
-    streamSimple: (model, context, options) => streamWith(model, context, options, !0)
-  };
-}
-function resolveConfiguredModelHeaders(model, config, extension, env) {
-  return resolveHeadersOrThrow(rawModelHeaders(model, config, extension), `model "${model.provider}/${model.id}"`, env);
-}
-function resolveCompatibilityRequestConfig(model, config, extension) {
-  let configured = resolveHeadersOrThrow({ ...configuredHeaders(config, extension), ...rawModelHeaders(model, config, extension) }, `model "${model.provider}/${model.id}"`);
-  return {
-    headers: model.headers || configured ? { ...model.headers, ...configured } : void 0,
-    authHeader: extension?.authHeader ?? config?.authHeader ?? !1
-  };
-}
-function configuredRequestAuthStatus(config, extension) {
-  let value = configuredApiKey(config, extension);
-  if (value === void 0)
-    return;
-  if (isCommandConfigValue(value))
-    return { configured: !0, source: "models_json_command" };
-  let names = getConfigValueEnvVarNames(value);
-  return names.length > 0 ? isConfigValueConfigured(value) ? { configured: !0, source: "environment", label: names.join(", ") } : { configured: !1 } : { configured: !0, source: extension?.apiKey !== void 0 ? "fallback" : "models_json_key" };
-}
-
-// packages/coding-agent/dist/core/runtime-credentials.js
-var RuntimeCredentials = class {
-  store;
-  overrides = /* @__PURE__ */ new Map();
-  constructor(store) {
-    this.store = store;
-  }
-  setRuntimeApiKey(providerId, apiKey) {
-    this.overrides.set(providerId, apiKey);
-  }
-  removeRuntimeApiKey(providerId) {
-    this.overrides.delete(providerId);
-  }
-  hasRuntimeApiKey(providerId) {
-    return this.overrides.has(providerId);
-  }
-  async read(providerId) {
-    let override = this.overrides.get(providerId);
-    return override ? { type: "api_key", key: override } : this.store.read(providerId);
-  }
-  async list() {
-    let entries = new Map((await this.store.list()).map((entry) => [entry.providerId, entry]));
-    for (let providerId of this.overrides.keys())
-      entries.set(providerId, { providerId, type: "api_key" });
-    return [...entries.values()];
-  }
-  modify(providerId, fn) {
-    return this.store.modify(providerId, fn);
-  }
-  async delete(providerId) {
-    this.overrides.delete(providerId), await this.store.delete(providerId);
-  }
-};
-
-// packages/coding-agent/dist/core/subscriptions.js
-import { join as join5 } from "path";
-
-// packages/coding-agent/dist/core/usage-limit.js
-var USAGE_LIMIT_ERROR_PATTERNS = [
-  // Provider-declared subscription/free-tier limit error types and wording
-  // (pi-ai NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN spirit).
-  "GoUsageLimitError",
-  "FreeUsageLimitError",
-  "Monthly usage limit reached",
-  "available balance",
-  "insufficient_quota",
-  "out of budget",
-  "quota exceeded",
-  "billing"
-], USAGE_LIMIT_ERROR_REGEXES = [
-  // Goal runtime USAGE_LIMIT_GOAL_ERROR_PATTERNS: usage caps, quota exhaustion,
-  // credit/balance exhaustion, payment required.
-  /usage[_\s-]*(?:limit|cap)|chatgpt.{0,32}usage/i,
-  /quota.{0,32}(?:reached|exceeded|exhausted|depleted)|(?:reached|exceeded|exhausted|depleted).{0,32}quota/i,
-  /insufficient[_\s-]*(?:quota|credits?)|out of credits|out of budget|available balance|payment required/i,
-  /(?:credit|balance).{0,32}(?:low|exhausted|depleted)|billing/i
-], AUTH_INVALID_ERROR_PATTERN = /\b401\b|unauthori[sz]ed|unauthenticated|invalid.{0,16}(?:api.?key|token|credentials?)|authentication.{0,16}failed/i;
-function isUsageLimitError(errorMessage) {
-  return errorMessage ? USAGE_LIMIT_ERROR_PATTERNS.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase())) ? !0 : USAGE_LIMIT_ERROR_REGEXES.some((pattern) => pattern.test(errorMessage)) : !1;
-}
-function isAuthInvalidError(errorMessage) {
-  return errorMessage ? AUTH_INVALID_ERROR_PATTERN.test(errorMessage) : !1;
-}
-var RESET_TIME_PATTERNS = [
-  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*s(ec)?/i,
-  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*m(in)?/i,
-  /reset(?:s|ting)?\s*(?:in|after|at)?\s*(\d+)\s*h(our|r)?/i,
-  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*s(ec)?/i,
-  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*m(in)?/i,
-  /(?:retry|try(?:\s+again)?|available)\s+(?:in|after|at)\s*(\d+)\s*h(our|r)?/i
-];
-function parseResetTimeMs(errorMessage) {
-  if (!errorMessage)
-    return;
-  let now = Date.now();
-  for (let pattern of RESET_TIME_PATTERNS) {
-    let match = errorMessage.match(pattern);
-    if (!match)
-      continue;
-    let value = Number.parseInt(match[1] ?? "", 10);
-    if (!Number.isFinite(value) || value <= 0)
-      continue;
-    let unit = pattern.source.includes("\\s*h") ? 36e5 : pattern.source.includes("\\s*m") ? 6e4 : 1e3;
-    return now + value * unit;
-  }
-  let isoMatch = errorMessage.match(/(?:reset|available).{0,12}(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)/i);
-  if (isoMatch?.[1]) {
-    let parsed = Date.parse(isoMatch[1]);
-    if (Number.isFinite(parsed) && parsed > now)
-      return parsed;
-  }
-}
-
-// packages/coding-agent/dist/core/subscriptions.js
-var SubscriptionManager = class _SubscriptionManager {
-  data = {};
-  loaded = !1;
-  storage;
-  authStorage;
-  // In-process write queue so mutations serialize even before the file lock.
-  queue = Promise.resolve();
-  // Per-provider ids of keys exhausted without a parseable reset time.
-  // Process-local on purpose: infinite exhaustion is never persisted.
-  memoryExhausted = /* @__PURE__ */ new Map();
-  constructor(authStorage, storage) {
-    this.authStorage = authStorage, this.storage = storage;
-  }
-  static create(authStorage, path) {
-    return new _SubscriptionManager(authStorage, new FileAuthStorageBackend(path ?? join5(getAgentDir(), "subscriptions.json")));
-  }
-  static fromStorage(authStorage, storage) {
-    return new _SubscriptionManager(authStorage, storage);
-  }
-  static inMemory(authStorage, data = {}) {
-    let storage = new InMemoryAuthStorageBackend();
-    return storage.withLock(() => ({ result: void 0, next: JSON.stringify(data, null, 2) })), _SubscriptionManager.fromStorage(authStorage, storage);
-  }
-  parseStorageData(content) {
-    return content ? JSON.parse(content) : {};
-  }
-  ensureLoaded() {
-    if (this.loaded)
-      return;
-    this.loaded = !0;
-    let content;
-    try {
-      this.storage.withLock((current) => (content = current, { result: void 0 })), this.data = this.parseStorageData(content);
-    } catch {
-    }
-  }
-  enqueue(fn) {
-    let next = this.queue.then(fn);
-    return this.queue = next.catch(() => {
-    }), next;
-  }
-  persist() {
-    return this.storage.withLockAsync(async () => ({
-      result: void 0,
-      next: JSON.stringify(this.data, null, 2)
-    }));
-  }
-  /** Raw stored credential read via the modify path (returning undefined leaves it unchanged). */
-  async readRawCredential(providerId) {
-    let current;
-    return await this.authStorage.modify(providerId, async (credential) => {
-      current = credential;
-    }), current;
-  }
-  /**
-   * Pool for a provider, lazy-importing an existing stored api_key credential
-   * as "Sub 1" on first access. OAuth credentials are not imported.
-   */
-  async ensurePool(providerId) {
-    this.ensureLoaded();
-    let existing = this.data[providerId];
-    if (existing)
-      return existing;
-    let credential = await this.readRawCredential(providerId);
-    if (credential?.type !== "api_key" || credential.key === void 0)
-      return;
-    let pool = {
-      active: "1",
-      keys: [{ id: "1", name: "Sub 1", key: credential.key, addedAt: Date.now() }]
-    };
-    return this.data = { ...this.data, [providerId]: pool }, await this.persist(), pool;
-  }
-  nextId(pool) {
-    let max = 0;
-    for (let entry of pool.keys) {
-      let numeric = Number.parseInt(entry.id, 10);
-      Number.isFinite(numeric) && numeric > max && (max = numeric);
-    }
-    return String(max + 1);
-  }
-  async mirrorActive(providerId, key) {
-    await this.authStorage.modify(providerId, async () => ({ type: "api_key", key }));
-  }
-  async list(providerId) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      return pool ? [...pool.keys] : [];
-    });
-  }
-  async getActive(providerId) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      return pool?.keys.find((entry) => entry.id === pool.active);
-    });
-  }
-  async addKey(providerId, key, name) {
-    return this.enqueue(async () => {
-      this.ensureLoaded();
-      let pool = await this.ensurePool(providerId), id = pool ? this.nextId(pool) : "1", entry = { id, name: name ?? `Sub ${id}`, key, addedAt: Date.now() }, keys = [...pool?.keys ?? [], entry];
-      return this.data = { ...this.data, [providerId]: { active: id, keys } }, await this.persist(), await this.mirrorActive(providerId, key), entry;
-    });
-  }
-  async removeKey(providerId, id) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      if (!pool || !pool.keys.some((entry) => entry.id === id))
-        return;
-      let keys = pool.keys.filter((entry) => entry.id !== id);
-      if (this.memoryExhausted.get(providerId)?.delete(id), keys.length === 0) {
-        let data = { ...this.data };
-        delete data[providerId], this.data = data, await this.persist(), await this.authStorage.delete(providerId);
-        return;
-      }
-      let active = pool.active;
-      if (active === id) {
-        active = keys[0]?.id ?? active, this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
-        let promoted = keys.find((entry) => entry.id === active);
-        promoted && await this.mirrorActive(providerId, promoted.key);
-        return;
-      }
-      this.data = { ...this.data, [providerId]: { active, keys } }, await this.persist();
-    });
-  }
-  async renameKey(providerId, id, name) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      if (!pool)
-        return;
-      let keys = pool.keys.map((entry) => entry.id === id ? { ...entry, name } : entry);
-      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
-    });
-  }
-  async setActive(providerId, id) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId), entry = pool?.keys.find((candidate) => candidate.id === id);
-      !pool || !entry || (this.data = { ...this.data, [providerId]: { ...pool, active: id } }, await this.persist(), await this.mirrorActive(providerId, entry.key));
-    });
-  }
-  /**
-   * Mark the active key exhausted and rotate to the next non-exhausted key in
-   * round-robin order. A parseable reset time is persisted as exhaustedUntil;
-   * otherwise the exhaustion is process-local only. Returns the new active key,
-   * or null when no non-exhausted alternative exists (current key stays active).
-   */
-  async rotateOnFailure(providerId, errorMessage, now = Date.now()) {
-    return this.enqueue(async () => {
-      let pool = await this.ensurePool(providerId);
-      if (!pool)
-        return null;
-      let currentIndex = pool.keys.findIndex((entry) => entry.id === pool.active);
-      if (currentIndex === -1)
-        return null;
-      let current = pool.keys[currentIndex];
-      if (!current)
-        return null;
-      let resetAt = parseResetTimeMs(errorMessage), keys = pool.keys;
-      if (resetAt !== void 0 && resetAt > now)
-        keys = pool.keys.map((entry) => entry.id === current.id ? { ...entry, exhaustedUntil: resetAt, lastError: errorMessage } : entry);
-      else {
-        let set = this.memoryExhausted.get(providerId) ?? /* @__PURE__ */ new Set();
-        set.add(current.id), this.memoryExhausted.set(providerId, set);
-      }
-      let isExhausted = (entry) => this.memoryExhausted.get(providerId)?.has(entry.id) === !0 || entry.exhaustedUntil !== void 0 && entry.exhaustedUntil > now;
-      for (let offset = 1; offset < keys.length; offset++) {
-        let candidate = keys[(currentIndex + offset) % keys.length];
-        if (!(!candidate || isExhausted(candidate)))
-          return this.data = { ...this.data, [providerId]: { active: candidate.id, keys } }, await this.persist(), await this.mirrorActive(providerId, candidate.key), candidate;
-      }
-      return keys !== pool.keys && (this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist()), null;
-    });
-  }
-  /** Manual reactivate: clears persisted and process-local exhaustion for a key. */
-  async clearExhaustion(providerId, id) {
-    return this.enqueue(async () => {
-      this.memoryExhausted.get(providerId)?.delete(id);
-      let pool = await this.ensurePool(providerId);
-      if (!pool)
-        return;
-      let target = pool.keys.find((entry) => entry.id === id);
-      if (!target || target.exhaustedUntil === void 0 && target.lastError === void 0)
-        return;
-      let keys = pool.keys.map((entry) => {
-        if (entry.id !== id)
-          return entry;
-        let { exhaustedUntil: _exhaustedUntil, lastError: _lastError, ...rest } = entry;
-        return rest;
-      });
-      this.data = { ...this.data, [providerId]: { ...pool, keys } }, await this.persist();
-    });
-  }
-};
-
-// packages/coding-agent/dist/core/user-models.js
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
-var USER_MODELS_FILENAME = "user-models.json";
-function userModelsPath(agentDir = getAgentDir()) {
-  return join6(agentDir, USER_MODELS_FILENAME);
-}
-function isRecord3(value) {
-  return typeof value == "object" && value !== null && !Array.isArray(value);
-}
-function asFiniteNumber3(value) {
-  if (typeof value == "number" && Number.isFinite(value))
-    return value;
-}
-function parseUserEntry(value) {
-  if (!isRecord3(value))
-    return;
-  let id = typeof value.id == "string" ? value.id.trim() : "", provider = typeof value.provider == "string" ? value.provider.trim() : "";
-  if (!id || !provider)
-    return;
-  let parsedInput = Array.isArray(value.input) ? value.input.filter((entry) => entry === "text" || entry === "image") : ["text"], input = parsedInput.length > 0 ? parsedInput : ["text"], cost = isRecord3(value.cost) ? {
-    input: asFiniteNumber3(value.cost.input) ?? 0,
-    output: asFiniteNumber3(value.cost.output) ?? 0,
-    cacheRead: asFiniteNumber3(value.cost.cacheRead) ?? 0,
-    cacheWrite: asFiniteNumber3(value.cost.cacheWrite) ?? 0
-  } : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-  return {
-    id,
-    name: typeof value.name == "string" && value.name.trim() ? value.name : id,
-    api: typeof value.api == "string" && value.api.trim() ? value.api : "openai-completions",
-    provider,
-    baseUrl: typeof value.baseUrl == "string" ? value.baseUrl : "",
-    reasoning: value.reasoning === !0,
-    input,
-    cost,
-    contextWindow: asFiniteNumber3(value.contextWindow) ?? 128e3,
-    maxTokens: asFiniteNumber3(value.maxTokens) ?? 8192,
-    compat: isRecord3(value.compat) ? value.compat : void 0,
-    thinkingLevelMap: isRecord3(value.thinkingLevelMap) ? value.thinkingLevelMap : void 0,
-    source: "user"
-  };
-}
-function emptyUserModels() {
-  return { version: 1, models: [] };
-}
-function readUserModels(path) {
-  try {
-    if (!existsSync4(path))
-      return emptyUserModels();
-    let parsed = JSON.parse(readFileSync4(path, "utf-8"));
-    if (!isRecord3(parsed) || !Array.isArray(parsed.models))
-      return emptyUserModels();
-    let models = [];
-    for (let entry of parsed.models) {
-      let model = parseUserEntry(entry);
-      model && models.push(model);
-    }
-    return { version: asFiniteNumber3(parsed.version) ?? 1, models };
-  } catch {
-    return emptyUserModels();
-  }
-}
-function writeUserModels(file, path) {
-  mkdirSync4(dirname4(path), { recursive: !0, mode: 448 }), writeFileSync4(path, `${JSON.stringify({ version: file.version ?? 1, models: file.models }, null, 2)}
-`, "utf-8");
-}
-function evictUserModelsOnOfficial(user, officialKeys) {
-  let hits = new Set(officialKeys), kept = [], evicted = [];
-  for (let model of user.models)
-    hits.has(modelKey(model.provider, model.id)) ? evicted.push(model) : kept.push(model);
-  return { next: { version: user.version, models: kept }, evicted };
-}
-function evictUserModelsByProvider(user, providerId) {
-  let kept = [], evicted = [];
-  for (let model of user.models)
-    model.provider === providerId ? evicted.push(model) : kept.push(model);
-  return { next: { version: user.version, models: kept }, evicted };
-}
-function upsertUserModels(existing, rows) {
-  let byKey = new Map(existing.models.map((model) => [modelKey(model.provider, model.id), model]));
-  for (let row of rows)
-    byKey.set(modelKey(row.provider, row.id), { ...row, source: "user" });
-  return { version: existing.version ?? 1, models: [...byKey.values()] };
-}
-function userEntryToModel(entry) {
-  return {
-    id: entry.id,
-    name: entry.name,
-    api: entry.api,
-    provider: entry.provider,
-    baseUrl: entry.baseUrl,
-    reasoning: entry.reasoning,
-    input: entry.input,
-    cost: entry.cost,
-    contextWindow: entry.contextWindow,
-    maxTokens: entry.maxTokens,
-    compat: entry.compat,
-    thinkingLevelMap: entry.thinkingLevelMap
-  };
-}
-var UserModelsStore = class {
-  path;
-  file;
-  constructor(path) {
-    this.path = path, this.file = path ? readUserModels(path) : emptyUserModels();
-  }
-  list() {
-    return this.file.models;
-  }
-  keys() {
-    return new Set(this.file.models.map((model) => modelKey(model.provider, model.id)));
-  }
-  modelsFor(providerId) {
-    return this.file.models.filter((model) => model.provider === providerId).map(userEntryToModel);
-  }
-  evictOfficial(officialKeys) {
-    let { next, evicted } = evictUserModelsOnOfficial(this.file, officialKeys);
-    return evicted.length > 0 && (this.file = next, this.persist()), evicted;
-  }
-  evictProvider(providerId) {
-    let { next, evicted } = evictUserModelsByProvider(this.file, providerId);
-    return evicted.length > 0 && (this.file = next, this.persist()), evicted;
-  }
-  upsert(rows) {
-    rows.length !== 0 && (this.file = upsertUserModels(this.file, rows), this.persist());
-  }
-  persist() {
-    if (this.path)
-      try {
-        writeUserModels(this.file, this.path);
-      } catch {
-      }
-  }
-};
-
-// packages/coding-agent/dist/core/model-runtime.js
-function mergeHeaders(base, override) {
-  if (!base && !override)
-    return;
-  let merged = { ...base };
-  for (let [name, value] of Object.entries(override ?? {})) {
-    let lowerName = name.toLowerCase();
-    for (let existingName of Object.keys(merged))
-      existingName.toLowerCase() === lowerName && delete merged[existingName];
-    merged[name] = value;
-  }
-  return merged;
-}
-var ModelRuntime = class _ModelRuntime {
-  models;
-  credentials;
-  /** lunr: per-provider subscription-key pools; rotation mirrors the active key into the credential store. */
-  subscriptionManager;
-  defaultBuiltins;
-  builtins = /* @__PURE__ */ new Map();
-  extensionProviders = /* @__PURE__ */ new Map();
-  compositionErrors = /* @__PURE__ */ new Map();
-  modelsPath;
-  allowModelNetwork;
-  config;
-  snapshot = {
-    all: [],
-    available: [],
-    configuredProviders: /* @__PURE__ */ new Set(),
-    storedProviders: /* @__PURE__ */ new Set(),
-    auth: /* @__PURE__ */ new Map()
-  };
-  availabilityRefresh;
-  availabilityError;
-  modelsStore;
-  overlay = new CatalogOverlaySource();
-  userModels;
-  officialCachePath;
-  lastCatalogRefresh = { aborted: !1, errors: /* @__PURE__ */ new Map(), live: [], incomplete: [] };
-  lastOfficial;
-  catalogRefresh;
-  catalogRefreshAllowsNetwork = !1;
-  nextAutomaticRefresh = 0;
-  automaticRefreshIdentity = "";
-  grokHome;
-  constructor(credentials, config, modelsPath, modelsStore, providers, allowModelNetwork, subscriptionManager, catalogDir, grokHome) {
-    this.credentials = credentials, this.config = config, this.modelsPath = modelsPath, this.modelsStore = modelsStore, this.allowModelNetwork = allowModelNetwork, this.subscriptionManager = subscriptionManager, this.userModels = new UserModelsStore(catalogDir ? userModelsPath(catalogDir) : void 0), this.officialCachePath = catalogDir ? officialCatalogCachePath(catalogDir) : void 0, this.grokHome = grokHome, this.defaultBuiltins = new Map(providers.map((provider) => [provider.id, provider]));
-    for (let [providerId, provider] of this.defaultBuiltins)
-      this.builtins.set(providerId, provider);
-    this.models = createModels({ credentials, modelsStore }), this.rebuildProviders();
-  }
-  static async create(options = {}) {
-    let rawStore = options.credentials ?? AuthStorage.create(options.authPath), grokHomeDisabled = options.grokHome === null || options.grokHome === void 0 && options.credentials !== void 0, grokHome = grokHomeDisabled ? void 0 : options.grokHome ?? void 0, baseStore = grokHomeDisabled ? rawStore : wrapXaiGrokCliCredentials(rawStore, { grokHome }), credentials = new RuntimeCredentials(baseStore), subscriptionManager = options.subscriptions ?? (options.credentials && !options.authPath ? SubscriptionManager.inMemory(baseStore) : SubscriptionManager.create(baseStore, options.authPath ? join7(dirname5(options.authPath), "subscriptions.json") : void 0)), modelsPath = options.modelsPath === null ? void 0 : options.modelsPath ?? join7(getAgentDir(), "models.json"), config = await ModelConfig.load(modelsPath), modelsStore = options.modelsStore ?? (modelsPath ? new FileModelsStore(options.modelsStorePath ?? join7(dirname5(modelsPath), "models-store.json")) : new InMemoryCodingAgentModelsStore()), providers = builtinProviderCatalog.builtinProviders(), catalogDir = modelsPath ? dirname5(modelsPath) : options.authPath ? dirname5(options.authPath) : void 0, runtime = new _ModelRuntime(credentials, config, modelsPath, modelsStore, providers, options.allowModelNetwork ?? process.env.PI_OFFLINE === void 0, subscriptionManager, catalogDir, grokHome);
-    return runtime.configureRadiusProviders(), runtime.rebuildProviders(), await runtime.refresh({ allowNetwork: !1 }), runtime;
-  }
-  configureRadiusProviders() {
-    this.builtins.clear();
-    for (let [providerId, provider] of this.defaultBuiltins)
-      this.builtins.set(providerId, provider);
-    for (let providerId of this.config.getProviderIds()) {
-      let config = this.config.getProvider(providerId);
-      config?.oauth !== "radius" || !config.baseUrl || this.builtins.set(providerId, builtinProviderCatalog.radiusProvider({
-        id: providerId,
-        name: config.name ?? providerId,
-        gateway: config.baseUrl.replace(/\/v1\/?$/u, "")
-      }));
-    }
-  }
-  providerIds() {
-    return /* @__PURE__ */ new Set([...this.builtins.keys(), ...this.config.getProviderIds(), ...this.extensionProviders.keys()]);
-  }
-  recomposeProvider(providerId) {
-    let base = this.builtins.get(providerId), extension = this.extensionProviders.get(providerId);
-    if (!base && !this.config.getProvider(providerId) && !extension) {
-      this.models.deleteProvider(providerId), this.compositionErrors.delete(providerId);
-      return;
-    }
-    if (base && !this.config.getProvider(providerId) && !extension) {
-      this.models.setProvider(this.withLocalCatalog(base)), this.compositionErrors.delete(providerId);
-      return;
-    }
-    try {
-      this.models.setProvider(composeModelProvider(providerId, base ? this.withLocalCatalog(base) : void 0, this.config, extension)), this.compositionErrors.delete(providerId);
-    } catch (error) {
-      this.compositionErrors.set(providerId, error instanceof Error ? error.message : String(error)), base ? this.models.setProvider(this.withLocalCatalog(base)) : this.models.deleteProvider(providerId);
-    }
-  }
-  withLocalCatalog(provider) {
-    return withCatalogOverlay(provider, this.overlay);
-  }
-  bakedInModels(providerId) {
-    return [...this.defaultBuiltins.get(providerId)?.getModels() ?? []];
-  }
-  rebuildProviders() {
-    this.models.clearProviders(), this.compositionErrors.clear();
-    for (let providerId of this.providerIds())
-      this.recomposeProvider(providerId);
-    this.updateModelSnapshot();
-  }
-  updateModelSnapshot() {
-    let all = [...this.models.getModels()];
-    this.snapshot = {
-      ...this.snapshot,
-      all,
-      available: all.filter((model) => this.snapshot.configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
-    };
-  }
-  isCatalogModelAvailable(model) {
-    return !!this.config.getProvider(model.provider)?.models?.some((row) => row.id === model.id) || !!this.extensionProviders.get(model.provider)?.models?.some((row) => row.id === model.id) || this.overlay.isAvailable(model);
-  }
-  async listStoredProviderIds() {
-    let credentials = await this.credentials.list();
-    return new Set(credentials.map((entry) => entry.providerId));
-  }
-  /** `/model` lists stored creds + models.json/extension keys, never ambient envApiKeyAuth. */
-  configuredProviderIds(storedProviders) {
-    let configured = new Set(storedProviders);
-    for (let provider of this.models.getProviders())
-      configuredRequestAuthStatus(this.config.getProvider(provider.id), this.extensionProviders.get(provider.id))?.configured && configured.add(provider.id);
-    return configured;
-  }
-  userModelsForStoredProviders(storedProviders) {
-    return this.userModels.list().filter((row) => storedProviders.has(row.provider)).map(userEntryToModel);
-  }
-  async runAvailabilityRefresh() {
-    let providers = this.models.getProviders(), [available, checks, storedProviders] = await Promise.all([
-      this.models.getAvailable(),
-      Promise.all(providers.map(async (provider) => [
-        provider.id,
-        await this.models.checkAuth(provider.id)
-      ])),
-      this.listStoredProviderIds()
-    ]), auth = new Map(checks), configuredProviders = this.configuredProviderIds(storedProviders);
-    this.snapshot = {
-      all: [...this.models.getModels()],
-      available: available.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model)),
-      configuredProviders,
-      storedProviders,
-      auth
-    }, this.availabilityError = void 0;
-  }
-  queueAvailabilityRefresh(after) {
-    let tracked = (after ?? Promise.resolve()).catch(() => {
-    }).then(() => this.runAvailabilityRefresh()).catch((error) => {
-      throw this.availabilityError = error instanceof Error ? error.message : String(error), error;
-    }).finally(() => {
-      this.availabilityRefresh === tracked && (this.availabilityRefresh = void 0);
-    });
-    return this.availabilityRefresh = tracked, tracked;
-  }
-  /** Coalesce concurrent readers onto the pending refresh. */
-  refreshAvailability() {
-    return this.availabilityRefresh ?? this.queueAvailabilityRefresh(void 0);
-  }
-  /** Mutations must not observe an in-flight refresh started before them. */
-  forceRefreshAvailability() {
-    return this.queueAvailabilityRefresh(this.availabilityRefresh);
-  }
-  getProviders() {
-    return this.models.getProviders();
-  }
-  getProvider(providerId) {
-    return this.models.getProvider(providerId);
-  }
-  getModels(providerId) {
-    return this.models.getModels(providerId);
-  }
-  getModel(providerId, modelId) {
-    return this.models.getModel(providerId, modelId);
-  }
-  async checkAuth(providerId) {
-    return this.models.checkAuth(providerId);
-  }
-  async getAvailable(providerId) {
-    if (providerId) {
-      if (this.availabilityRefresh)
-        return await this.availabilityRefresh, this.snapshot.available.filter((model) => model.provider === providerId);
-      try {
-        return (await this.models.getAvailable(providerId)).filter((model) => this.isCatalogModelAvailable(model));
-      } catch (error) {
-        throw this.availabilityError = error instanceof Error ? error.message : String(error), error;
-      }
-    }
-    return await this.refreshAvailability(), this.snapshot.available;
-  }
-  getAvailableSnapshot() {
-    return this.snapshot.available;
-  }
-  getError() {
-    let errors = [], configError = this.config.getError();
-    configError && errors.push(configError);
-    for (let [providerId, error] of this.compositionErrors)
-      errors.push(`Provider "${providerId}": ${error}`);
-    return this.availabilityError && errors.push(`Availability refresh: ${this.availabilityError}`), errors.length > 0 ? errors.join(`
+  TODO_TOOL_NAMES
+} from "./chunk-CCCN2UCX.js";
+import {
+  DefaultResourceLoader,
+  createSyntheticSourceInfo,
+  expandPromptTemplate,
+  formatSkillsForPrompt
+} from "./chunk-IQIEU7SB.js";
+import {
+  stripFrontmatter
+} from "./chunk-QFWG2RVL.js";
+import {
+  createAllToolDefinitions,
+  createLocalBashOperations,
+  createToolDefinitionFromAgentTool,
+  wrapToolDefinition
+} from "./chunk-VSSXXL36.js";
+import {
+  DEFAULT_MAX_BYTES,
+  truncateTail
+} from "./chunk-53YJI7JU.js";
+import {
+  stripAnsi
+} from "./chunk-5ZQXRPMC.js";
+import {
+  ModelRuntime,
+  isAuthInvalidError,
+  isUsageLimitError
+} from "./chunk-GS66LV4M.js";
+import {
+  SettingsManager
+} from "./chunk-WADV2VDS.js";
+import {
+  DEFAULT_THINKING_LEVEL,
+  calculateContextTokens,
+  collectEntriesForBranchSummary,
+  compact,
+  estimateContextTokens,
+  estimateTokens,
+  findInitialModel,
+  generateBranchSummary,
+  prepareCompaction,
+  shouldCompact
+} from "./chunk-OFKSVRV7.js";
+import {
+  ExtensionRunner,
+  emitSessionShutdownEvent
+} from "./chunk-5BNJ4JUH.js";
+import {
+  getSubagentCancellation
+} from "./chunk-BBUVIEZB.js";
+import {
+  gateToolCall
+} from "./chunk-5D7LC2ZQ.js";
+import {
+  isUserInstructionsPath,
+  loadSelectedUserInstructions
+} from "./chunk-M3LZLQW2.js";
+import {
+  list
+} from "./chunk-KKUTQQV7.js";
+import {
+  sanitizeBinaryOutput
+} from "./chunk-CSFI6YXL.js";
+import {
+  SessionTransferError
+} from "./chunk-AZJHNQKQ.js";
+import {
+  CURRENT_SESSION_VERSION,
+  SessionManager,
+  getDefaultSessionDir,
+  getLatestCompactionEntry
+} from "./chunk-XLTL257W.js";
+import {
+  convertToLlm
+} from "./chunk-FVDOXRUD.js";
+import {
+  MEMORY_TOOL_NAMES
+} from "./chunk-UJOCPOMX.js";
+import {
+  SessionOwnership,
+  canonicalSessionPath
+} from "./chunk-UAEOTO52.js";
+import {
+  measureStartup,
+  time
+} from "./chunk-PVCDKGR6.js";
+import {
+  getThemeByName,
+  theme
+} from "./chunk-7QWNYZDI.js";
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  getDocsPath,
+  getExamplesPath,
+  getReadmePath,
+  resolvePath
+} from "./chunk-FQMM2EZ2.js";
 
-`) : void 0;
-  }
-  getRegisteredProviderConfig(providerId) {
-    return this.extensionProviders.get(providerId);
-  }
-  getRegisteredProviderIds() {
-    return [...this.extensionProviders.keys()];
-  }
-  /** @internal Compatibility fallback for ModelRegistry when provider auth is unconfigured. */
-  getCompatibilityRequestConfig(model) {
-    return resolveCompatibilityRequestConfig(model, this.config.getProvider(model.provider), this.extensionProviders.get(model.provider));
-  }
-  isUsingOAuth(providerId) {
-    return this.snapshot.auth.get(providerId)?.type === "oauth";
-  }
-  hasConfiguredAuth(providerId) {
-    return this.snapshot.configuredProviders.has(providerId);
-  }
-  async getAuth(providerOrModel, overrides = {}) {
-    if (typeof providerOrModel == "string")
-      return this.models.getAuth(providerOrModel, overrides);
-    let resolution = await this.models.getAuth(providerOrModel, overrides);
-    if (!resolution)
-      return;
-    let configuredHeaders2 = resolveConfiguredModelHeaders(providerOrModel, this.config.getProvider(providerOrModel.provider), this.extensionProviders.get(providerOrModel.provider), { ...resolution.env ?? {}, ...overrides.env ?? {} });
-    return {
-      ...resolution,
-      auth: {
-        ...resolution.auth,
-        headers: mergeHeaders(resolution.auth.headers, configuredHeaders2)
-      }
-    };
-  }
-  /** lunr: whether a runtime --api-key override is active for the provider (it shadows auth.json). */
-  hasRuntimeApiKey(providerId) {
-    return this.credentials.hasRuntimeApiKey(providerId);
-  }
-  async setRuntimeApiKey(providerId, apiKey, options) {
-    this.credentials.setRuntimeApiKey(providerId, apiKey);
-    let auth = new Map(this.snapshot.auth).set(providerId, { type: "api_key", source: "runtime API key" }), configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId), storedProviders = new Set(this.snapshot.storedProviders).add(providerId);
-    this.snapshot = {
-      ...this.snapshot,
-      auth,
-      configuredProviders,
-      storedProviders,
-      available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
-    }, await this.refresh({ allowNetwork: options?.allowNetwork ?? this.allowModelNetwork });
-  }
-  async removeRuntimeApiKey(providerId) {
-    this.credentials.removeRuntimeApiKey(providerId), await this.refresh({ allowNetwork: this.allowModelNetwork });
-  }
-  /** lunr: whether network model-catalog fetches are allowed (offline mode disables them). */
-  isNetworkAllowed() {
-    return this.allowModelNetwork;
-  }
-  listCredentials() {
-    return this.credentials.list();
-  }
-  getProviderAuthStatus(providerId) {
-    if (this.credentials.hasRuntimeApiKey(providerId))
-      return { configured: !0, source: "runtime" };
-    if (this.snapshot.storedProviders.has(providerId))
-      return { configured: !0, source: "stored" };
-    let configured = configuredRequestAuthStatus(this.config.getProvider(providerId), this.extensionProviders.get(providerId));
-    if (configured)
-      return configured;
-    let check = this.snapshot.auth.get(providerId);
-    return check ? { configured: !0, source: "environment", label: check.source } : { configured: !1 };
-  }
-  async prepareRequest(model, options) {
-    let provider = this.models.getProvider(model.provider);
-    if (!provider)
-      throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
-    let resolution = await this.getAuth(model, { apiKey: options?.apiKey, env: options?.env });
-    if (!resolution)
-      throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
-    let { transformHeaders, ...providerOptions } = options ?? {}, headers = mergeHeaders(resolution.auth.headers, providerOptions.headers);
-    transformHeaders && (headers = await transformHeaders(headers ?? {}));
-    let env = resolution.env || providerOptions.env ? { ...resolution.env ?? {}, ...providerOptions.env ?? {} } : void 0;
-    return {
-      provider,
-      model: resolution.auth.baseUrl ? { ...model, baseUrl: resolution.auth.baseUrl } : model,
-      options: {
-        ...providerOptions,
-        apiKey: providerOptions.apiKey ?? resolution.auth.apiKey,
-        headers,
-        env
-      }
-    };
-  }
-  stream(model, context, options) {
-    return lazyStream2(model, async () => {
-      let prepared = await this.prepareRequest(model, options);
-      return prepared.provider.stream(prepared.model, context, prepared.options);
-    });
-  }
-  complete(model, context, options) {
-    return this.stream(model, context, options).result();
-  }
-  streamSimple(model, context, options) {
-    return lazyStream2(model, async () => {
-      let prepared = await this.prepareRequest(model, options);
-      return prepared.provider.streamSimple(prepared.model, context, prepared.options);
-    });
-  }
-  completeSimple(model, context, options) {
-    return this.streamSimple(model, context, options).result();
-  }
-  async login(providerId, type, interaction) {
-    let credential = await this.models.login(providerId, type, interaction);
-    return clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork }), credential;
-  }
-  async logout(providerId) {
-    await this.models.logout(providerId), await this.modelsStore.delete(providerId), this.userModels.evictProvider(providerId), this.overlay.setLive(providerId, []), this.recomposeProvider(providerId), clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork });
-  }
-  /** Copy a live Grok CLI SuperGrok session into lunR `auth.json`. */
-  async importGrokCliXaiAuth() {
-    let grok = readGrokCliXaiOAuth({ grokHome: this.grokHome });
-    if (!grok)
-      return;
-    let stored = await this.credentials.modify("xai", async () => grok);
-    return clearPlanUsageCache(), await this.refresh({ allowNetwork: this.allowModelNetwork }), stored;
-  }
-  async reloadConfig() {
-    this.config = await ModelConfig.load(this.modelsPath), this.configureRadiusProviders(), this.rebuildProviders(), await this.refresh({ allowNetwork: this.allowModelNetwork });
-  }
-  async refresh(options = {}) {
-    let allowNetwork = options.allowNetwork ?? this.allowModelNetwork;
-    if (this.catalogRefresh)
-      return this.catalogRefreshAllowsNetwork || !allowNetwork ? this.catalogRefresh : (await this.catalogRefresh.catch(() => {
-      }), this.refresh({ ...options, allowNetwork }));
-    let run = this.executeCatalogRefresh({ ...options, allowNetwork }).finally(() => {
-      this.catalogRefresh === run && (this.catalogRefresh = void 0, this.catalogRefreshAllowsNetwork = !1);
-    });
-    return this.catalogRefresh = run, this.catalogRefreshAllowsNetwork = allowNetwork, run;
-  }
-  async executeCatalogRefresh(refreshOptions) {
-    let official = await this.refreshOfficialCatalog(refreshOptions.allowNetwork, refreshOptions.signal), live = refreshOptions.allowNetwork ? await this.refreshLiveCatalogs(official ? officialModelKeys(official.catalog) : /* @__PURE__ */ new Set(), refreshOptions.signal) : await this.restoreLiveCatalogs(), result = await this.models.refresh(refreshOptions) ?? {
-      aborted: refreshOptions.signal?.aborted ?? !1,
-      errors: /* @__PURE__ */ new Map()
-    }, errors = new Map(result.errors);
-    for (let [id, error] of Object.entries(official?.errors ?? {}))
-      errors.set(id, new Error(error));
-    for (let entry of live)
-      (entry.status === "error" || entry.status === "timeout") && errors.set(entry.providerId, new Error(entry.error ?? entry.status));
-    this.updateModelSnapshot();
-    try {
-      await this.forceRefreshAvailability();
-    } catch {
-    }
-    let catalogResult = {
-      aborted: result.aborted,
-      errors,
-      official,
-      live,
-      incomplete: live.flatMap((entry) => entry.incomplete)
-    };
-    return this.lastCatalogRefresh = catalogResult, catalogResult;
-  }
-  getLastCatalogRefresh() {
-    return this.lastCatalogRefresh;
-  }
-  /** Called after first paint and by the picker; explicit /refresh always bypasses this gate. */
-  async refreshIfStale(options = {}) {
-    if (!this.allowModelNetwork || options.signal?.aborted)
-      return this.lastCatalogRefresh;
-    if (this.catalogRefresh)
-      return this.refresh({ allowNetwork: !0, signal: options.signal });
-    let providers = [...await this.listStoredProviderIds()].sort(), identity = (await Promise.all(providers.map(async (id) => this.scopeFor(id)))).join(":");
-    if (identity === this.automaticRefreshIdentity && Date.now() < this.nextAutomaticRefresh)
-      return this.lastCatalogRefresh;
-    this.automaticRefreshIdentity = identity, this.nextAutomaticRefresh = Date.now() + 6e4;
-    let result = await this.refresh({ allowNetwork: !0, signal: options.signal });
-    return !result.aborted && !result.errors.size && (this.nextAutomaticRefresh = Date.now() + 36e5), result;
-  }
-  async scopeFor(providerId) {
-    let provider = this.models.getProvider(providerId) ?? this.defaultBuiltins.get(providerId);
-    return catalogCacheScope(providerId, provider?.baseUrl ?? "", await this.credentials.read(providerId));
-  }
-  persistUserModels(rows) {
-    this.userModels.upsert(rows), this.overlay.setUser(this.userModelsForStoredProviders(this.snapshot.storedProviders)), this.updateModelSnapshot();
-  }
-  async refreshOfficialCatalog(allowNetwork, signal) {
-    let storedProviders = await this.listStoredProviderIds(), loaded = preferOfficialCatalog(this.lastOfficial, await loadOfficialCatalog({
-      allowNetwork,
-      cachePath: this.officialCachePath,
-      signal,
-      providerIds: [...storedProviders]
-    }));
-    this.lastOfficial = loaded;
-    let evicted = this.userModels.evictOfficial(officialModelKeys(loaded.catalog)), templateByProvider = /* @__PURE__ */ new Map(), officialModels = loaded.catalog.models.filter((entry) => storedProviders.has(entry.provider)).map((entry) => (templateByProvider.has(entry.provider) || templateByProvider.set(entry.provider, this.bakedInModels(entry.provider)[0]), officialEntryToModel(entry, templateByProvider.get(entry.provider))));
-    return this.overlay.setOfficial(officialModels), this.overlay.setUser(this.userModelsForStoredProviders(storedProviders)), { ...loaded, evictedUserRows: evicted.length };
-  }
-  async restoreLiveCatalogs() {
-    let storedProviders = await this.listStoredProviderIds(), results = [];
-    for (let providerId of LIVE_LIST_PROVIDER_IDS) {
-      let stored = storedProviders.has(providerId) ? await this.modelsStore.read(providerId) : void 0;
-      (!stored?.scope && providerId !== "openai-codex" || stored?.scope === await this.scopeFor(providerId)) && stored?.models ? this.overlay.setLive(providerId, stored.models) : this.overlay.setLive(providerId, []), results.push({
-        providerId,
-        status: "skipped",
-        discoveries: [],
-        added: 0,
-        total: stored?.models.length ?? 0,
-        incomplete: []
-      });
-    }
-    return results;
-  }
-  async refreshLiveCatalogs(officialKeys, signal) {
-    let storedProviders = await this.listStoredProviderIds(), known = knownModelKeys(LIVE_LIST_PROVIDER_IDS.flatMap((id) => this.bakedInModels(id)), officialKeys, this.userModels.keys());
-    return await Promise.all(LIVE_LIST_PROVIDER_IDS.map(async (providerId) => {
-      if (!storedProviders.has(providerId))
-        return this.overlay.setLive(providerId, []), {
-          providerId,
-          status: "skipped",
-          discoveries: [],
-          added: 0,
-          total: 0,
-          incomplete: []
-        };
-      let stored = await this.modelsStore.read(providerId), initialScope = await this.scopeFor(providerId);
-      if (stored?.models && (stored.scope === initialScope || !stored.scope && providerId !== "openai-codex") ? this.overlay.setLive(providerId, stored.models) : this.overlay.setLive(providerId, []), signal?.aborted)
-        return {
-          providerId,
-          status: "skipped",
-          discoveries: [],
-          added: 0,
-          total: stored?.models.length ?? 0,
-          incomplete: [],
-          error: "aborted"
-        };
-      let bakedIn = this.bakedInModels(providerId), baseUrl = (this.models.getProvider(providerId) ?? this.defaultBuiltins.get(providerId))?.baseUrl ?? bakedIn[0]?.baseUrl;
-      if (!baseUrl)
-        return {
-          providerId,
-          status: "skipped",
-          discoveries: [],
-          added: 0,
-          total: 0,
-          incomplete: []
-        };
-      let credential;
-      try {
-        credential = await this.refreshCredentialFor(providerId);
-      } catch (error) {
-        return {
-          providerId,
-          status: "error",
-          discoveries: [],
-          added: 0,
-          total: stored?.models.length ?? 0,
-          incomplete: [],
-          error: error instanceof Error ? error.message : String(error)
-        };
-      }
-      if (!credential)
-        return {
-          providerId,
-          status: "skipped",
-          discoveries: [],
-          added: 0,
-          total: stored?.models.length ?? 0,
-          incomplete: []
-        };
-      let requestScope = catalogCacheScope(providerId, baseUrl, credential), result = await fetchLiveProviderModels({
-        discoveryClientVersion: stored?.scope === requestScope ? stored.discoveryClientVersion : void 0,
-        providerId,
-        baseUrl,
-        bakedIn,
-        credential,
-        knownKeys: known,
-        signal
-      }), accountChanged = await this.scopeFor(providerId) !== requestScope;
-      if (accountChanged && this.overlay.setLive(providerId, []), signal?.aborted || accountChanged)
-        return { ...result, status: "skipped", discoveries: [], incomplete: [] };
-      if (result.status === "ok") {
-        let overlayModels = buildLiveOverlay(bakedIn, result.discoveries);
-        this.overlay.setLive(providerId, overlayModels);
-        try {
-          await this.modelsStore.write(providerId, {
-            models: overlayModels,
-            checkedAt: Date.now(),
-            scope: requestScope,
-            discoveryClientVersion: result.discoveryClientVersion
-          });
-        } catch {
-        }
-      }
-      return result;
-    }));
-  }
-  async refreshCredentialFor(providerId) {
-    let resolved = await this.getAuth(providerId), stored = await this.credentials.read(providerId);
-    if (stored?.type === "oauth")
-      return { ...stored, access: resolved?.auth.apiKey ?? stored.access };
-    if (resolved?.auth.apiKey)
-      return { type: "api_key", key: resolved.auth.apiKey, env: resolved.env };
-    if (stored?.type === "api_key" && stored.key)
-      return stored;
-  }
-  registerProvider(providerId, config) {
-    validateExtensionProvider(providerId, this.builtins.get(providerId), this.config.getProvider(providerId), config);
-    let effective = { ...this.extensionProviders.get(providerId) };
-    for (let [key, value] of Object.entries(config))
-      value !== void 0 && (effective[key] = value);
-    if (this.extensionProviders.set(providerId, effective), this.recomposeProvider(providerId), this.updateModelSnapshot(), this.snapshot.storedProviders.has(providerId) || configuredRequestAuthStatus(this.config.getProvider(providerId), effective)?.configured) {
-      let configuredProviders = new Set(this.snapshot.configuredProviders).add(providerId), auth = new Map(this.snapshot.auth);
-      auth.get(providerId) || auth.set(providerId, {
-        type: effective.oauth && !effective.apiKey ? "oauth" : "api_key",
-        source: "configured provider"
-      }), this.snapshot = {
-        ...this.snapshot,
-        auth,
-        configuredProviders,
-        available: this.snapshot.all.filter((model) => configuredProviders.has(model.provider) && this.isCatalogModelAvailable(model))
-      };
-    }
-    this.refresh({ allowNetwork: !1 });
-  }
-  unregisterProvider(providerId) {
-    this.extensionProviders.delete(providerId), this.recomposeProvider(providerId), this.updateModelSnapshot(), this.refresh({ allowNetwork: !1 });
-  }
-};
-async function refreshModelCandidatesForInit(runtime) {
-  return await runtime.refresh({ allowNetwork: !1 }), runtime.getAvailableSnapshot();
-}
+// packages/coding-agent/dist/core/agent-session-services.js
+import { join as join7 } from "node:path";
 
 // packages/coding-agent/dist/core/sdk.js
-import { join as join13 } from "node:path";
+import { join as join6 } from "node:path";
 import { Agent } from "@ashx-j/lunr-agent";
 import { clampThinkingLevel as clampThinkingLevel2 } from "@ashx-j/lunr-ai";
 
 // packages/coding-agent/dist/core/agent-session.js
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename, dirname as dirname7, join as join11, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
 import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple } from "@ashx-j/lunr-ai/compat";
 
 // packages/coding-agent/dist/utils/sleep.js
 function sleep(ms, signal) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve3, reject) => {
     if (signal?.aborted) {
       reject(new Error("Aborted"));
       return;
     }
-    let timeout = setTimeout(resolve4, ms);
+    let timeout = setTimeout(resolve3, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timeout), reject(new Error("Aborted"));
     });
@@ -2915,13 +128,13 @@ function sleep(ms, signal) {
 }
 
 // packages/coding-agent/dist/core/auth-guidance.js
-import { join as join8 } from "node:path";
+import { join } from "node:path";
 var UNKNOWN_PROVIDER = "unknown";
 function getProviderLoginHelp() {
   return [
     "Use /login to log into a provider via OAuth or API key. See:",
-    `  ${join8(getDocsPath(), "providers.md")}`,
-    `  ${join8(getDocsPath(), "models.md")}`
+    `  ${join(getDocsPath(), "providers.md")}`,
+    `  ${join(getDocsPath(), "models.md")}`
   ].join(`
 `);
 }
@@ -2945,13 +158,13 @@ ${getProviderLoginHelp()}`;
 import { randomBytes } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join2 } from "node:path";
 async function executeBashWithOperations(command, cwd, operations, options) {
   let outputChunks = [], outputBytes = 0, maxOutputBytes = 51200 * 2, tempFilePath, tempFileStream, totalBytes = 0, ensureTempFile = () => {
     if (tempFilePath)
       return;
     let id = randomBytes(8).toString("hex");
-    tempFilePath = join9(tmpdir(), `lunr-bash-${id}.log`), tempFileStream = createWriteStream(tempFilePath);
+    tempFilePath = join2(tmpdir(), `lunr-bash-${id}.log`), tempFileStream = createWriteStream(tempFilePath);
     for (let chunk of outputChunks)
       tempFileStream.write(chunk);
   }, decoder = new TextDecoder(), onData = (data) => {
@@ -3086,12 +299,12 @@ var ModelRegistry = class {
 };
 
 // packages/coding-agent/dist/core/rollback.js
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync5, renameSync as renameSync4, rmSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname6, join as join10, normalize, resolve } from "node:path";
-var ROLLBACK_BASE = join10(homedir2(), ".lunr", "rollback"), contexts = /* @__PURE__ */ new Map(), lastSessionId, globalSettingsManager, warningHandler;
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join3, normalize, resolve } from "node:path";
+var ROLLBACK_BASE = join3(homedir(), ".lunr", "rollback"), contexts = /* @__PURE__ */ new Map(), lastSessionId, globalSettingsManager, warningHandler;
 function setRollbackWarningHandler(handler) {
   warningHandler = handler;
 }
@@ -3151,8 +364,8 @@ function rollbackSnapshotBeforeWrite(absPath, sessionId) {
   let turn = ctx.turns[ctx.turns.length - 1];
   if (turn && !turn.files.has(absPath))
     try {
-      let existed = existsSync5(absPath), content;
-      existed && (content = readFileSync5(absPath)), turn.files.set(absPath, {
+      let existed = existsSync(absPath), content;
+      existed && (content = readFileSync(absPath)), turn.files.set(absPath, {
         existed,
         content,
         createdByTool: !0
@@ -3169,13 +382,13 @@ function captureTreeBaseline(ctx, cwd) {
     for (let { path } of entries) {
       if (!path)
         continue;
-      let abs = join10(cwd, path);
+      let abs = join3(cwd, path);
       if (!turn.files.has(abs))
         try {
-          let existed = existsSync5(abs);
+          let existed = existsSync(abs);
           turn.files.set(abs, {
             existed,
-            content: existed ? readFileSync5(abs) : void 0,
+            content: existed ? readFileSync(abs) : void 0,
             createdByTool: !1
           }), persistSnapshot(ctx, turn, abs);
         } catch {
@@ -3194,14 +407,14 @@ function captureTreeChanges(cwd, sessionId) {
     for (let { status, path, source } of entries) {
       if (!path)
         continue;
-      let abs = join10(cwd, path);
+      let abs = join3(cwd, path);
       if (!turn.files.has(abs))
         try {
           if (status === "??" || status.includes("R")) {
             if (turn.files.set(abs, { existed: !1, createdByTool: !1 }), persistSnapshot(ctx, turn, abs), status.includes("R") && source) {
-              let sourceAbs = join10(cwd, source);
+              let sourceAbs = join3(cwd, source);
               if (!turn.files.has(sourceAbs)) {
-                let headSrc = spawnSync2("git", ["show", `HEAD:${source}`], {
+                let headSrc = spawnSync("git", ["show", `HEAD:${source}`], {
                   cwd,
                   timeout: 5e3,
                   maxBuffer: 33554432
@@ -3214,7 +427,7 @@ function captureTreeChanges(cwd, sessionId) {
               }
             }
           } else {
-            let head = spawnSync2("git", ["show", `HEAD:${path}`], {
+            let head = spawnSync("git", ["show", `HEAD:${path}`], {
               cwd,
               timeout: 5e3,
               maxBuffer: 33554432
@@ -3233,7 +446,7 @@ function captureTreeChanges(cwd, sessionId) {
 }
 function gitPorcelain(ctx, cwd) {
   try {
-    let result = spawnSync2("git", ["status", "--porcelain", "-z"], { cwd, encoding: "utf8", timeout: 5e3 });
+    let result = spawnSync("git", ["status", "--porcelain", "-z"], { cwd, encoding: "utf8", timeout: 5e3 });
     if (result.error || result.status !== 0) {
       warnOnce(ctx, "Rollback tree scope: not a git repository (or git failed) \u2014 bash side-effects won't be captured.");
       return;
@@ -3264,21 +477,21 @@ function persistSnapshot(ctx, turn, absPath) {
     if (!snap)
       return;
     let turnDir = getTurnDir(ctx, turn.turnIndex);
-    mkdirSync5(turnDir, { recursive: !0 });
-    let manifestPath = join10(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
+    mkdirSync(turnDir, { recursive: !0 });
+    let manifestPath = join3(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
     if (snap.content) {
       let snapFile = snapFileName(absPath);
-      writeFileSync5(join10(turnDir, snapFile), snap.content), entry.snapFile = snapFile;
+      writeFileSync(join3(turnDir, snapFile), snap.content), entry.snapFile = snapFile;
     }
-    manifest.files[absPath] = entry, turn.cwd && (manifest.cwd = turn.cwd), writeFileSync5(manifestPath, JSON.stringify(manifest, null, 2));
+    manifest.files[absPath] = entry, turn.cwd && (manifest.cwd = turn.cwd), writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   } catch {
   }
 }
 function readManifest(path) {
-  if (!existsSync5(path))
+  if (!existsSync(path))
     return { files: {} };
   try {
-    let parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    let parsed = JSON.parse(readFileSync(path, "utf-8"));
     if (parsed && typeof parsed == "object" && !Array.isArray(parsed)) {
       let files = parsed.files;
       return {
@@ -3293,20 +506,20 @@ function readManifest(path) {
 }
 function loadPersistedTurns(ctx) {
   try {
-    let sessionDir = join10(ROLLBACK_BASE, ctx.sessionId);
-    if (!existsSync5(sessionDir))
+    let sessionDir = join3(ROLLBACK_BASE, ctx.sessionId);
+    if (!existsSync(sessionDir))
       return;
     let loaded = [];
     for (let dirName of readdirSync(sessionDir)) {
       let match = /^turn-(\d+)$/.exec(dirName);
       if (!match)
         continue;
-      let turnIndex = Number(match[1]), turnDir = join10(sessionDir, dirName), manifest = readManifest(join10(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
+      let turnIndex = Number(match[1]), turnDir = join3(sessionDir, dirName), manifest = readManifest(join3(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
       for (let [absPath, meta] of Object.entries(manifest.files)) {
         let content;
         if (meta.snapFile)
           try {
-            content = readFileSync5(join10(turnDir, meta.snapFile));
+            content = readFileSync(join3(turnDir, meta.snapFile));
           } catch {
             content = void 0;
           }
@@ -3319,12 +532,12 @@ function loadPersistedTurns(ctx) {
   }
 }
 function getTurnDir(ctx, turnIndex) {
-  return join10(ROLLBACK_BASE, ctx.sessionId, `turn-${turnIndex}`);
+  return join3(ROLLBACK_BASE, ctx.sessionId, `turn-${turnIndex}`);
 }
 function cleanupTurnFiles(ctx, turn) {
   try {
     let dir = getTurnDir(ctx, turn.turnIndex);
-    existsSync5(dir) && rmSync(dir, { recursive: !0, force: !0 });
+    existsSync(dir) && rmSync(dir, { recursive: !0, force: !0 });
   } catch {
   }
 }
@@ -3335,10 +548,10 @@ function isPathUnderRoot(absPath, root) {
 function isWithinAllowedRoots(absPath, turn) {
   return turn.cwd ? [
     ROLLBACK_BASE,
-    join10(homedir2(), CONFIG_DIR_NAME),
+    join3(homedir(), CONFIG_DIR_NAME),
     // lunr: agent settings / cron jobs.json live under the config dir
     // lunr: simple-memory lives next to the lunr agent dir (~/.lunr/simple-memory)
-    join10(dirname6(getAgentDir()), "simple-memory"),
+    join3(dirname(getAgentDir()), "simple-memory"),
     resolve(turn.cwd)
   ].some((root) => isPathUnderRoot(absPath, root)) : !0;
 }
@@ -3380,10 +593,10 @@ function rollbackLastTurn(sessionId) {
         continue;
       }
       if (snap.existed && snap.content) {
-        if (!snap.createdByTool && existsSync5(absPath) && readFileSync5(absPath).equals(snap.content))
+        if (!snap.createdByTool && existsSync(absPath) && readFileSync(absPath).equals(snap.content))
           continue;
-        mkdirSync5(dirname6(absPath), { recursive: !0 }), writeFileSync5(absPath, snap.content), restored.push(absPath);
-      } else snap.existed || (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync5(absPath) && (unlinkSync4(absPath), deleted.push(absPath));
+        mkdirSync(dirname(absPath), { recursive: !0 }), writeFileSync(absPath, snap.content), restored.push(absPath);
+      } else snap.existed || (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync(absPath) && (unlinkSync(absPath), deleted.push(absPath));
     } catch {
     }
   return cleanupTurnFiles(ctx, turn), ctx.turns.pop(), { restored, deleted, turnsConsumed };
@@ -3394,11 +607,11 @@ function migrateRollbackSession(oldSessionId, newSessionId) {
   let ctx = contexts.get(oldSessionId);
   ctx && (contexts.delete(oldSessionId), ctx.sessionId = newSessionId, contexts.set(newSessionId, ctx));
   try {
-    let oldDir = join10(ROLLBACK_BASE, oldSessionId), newDir = join10(ROLLBACK_BASE, newSessionId);
-    if (existsSync5(oldDir)) {
-      existsSync5(newDir) && rmSync(newDir, { recursive: !0, force: !0 });
+    let oldDir = join3(ROLLBACK_BASE, oldSessionId), newDir = join3(ROLLBACK_BASE, newSessionId);
+    if (existsSync(oldDir)) {
+      existsSync(newDir) && rmSync(newDir, { recursive: !0, force: !0 });
       try {
-        renameSync4(oldDir, newDir);
+        renameSync(oldDir, newDir);
       } catch {
         cpSync(oldDir, newDir, { recursive: !0 }), rmSync(oldDir, { recursive: !0, force: !0 });
       }
@@ -3412,8 +625,8 @@ function clearRollback(sessionId) {
       for (let turn of ctx2.turns)
         cleanupTurnFiles(ctx2, turn);
       try {
-        let sessionDir = join10(ROLLBACK_BASE, ctx2.sessionId);
-        existsSync5(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
+        let sessionDir = join3(ROLLBACK_BASE, ctx2.sessionId);
+        existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
       } catch {
       }
     }
@@ -3425,15 +638,15 @@ function clearRollback(sessionId) {
     for (let turn of ctx.turns)
       cleanupTurnFiles(ctx, turn);
     try {
-      let sessionDir = join10(ROLLBACK_BASE, sessionId);
-      existsSync5(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
+      let sessionDir = join3(ROLLBACK_BASE, sessionId);
+      existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
     } catch {
     }
     contexts.delete(sessionId);
   }
 }
 function snapFileName(absPath) {
-  return `${createHash3("sha1").update(absPath).digest("hex")}.snap`;
+  return `${createHash("sha1").update(absPath).digest("hex")}.snap`;
 }
 
 // packages/coding-agent/dist/core/system-prompt.js
@@ -3463,7 +676,8 @@ ${content}
     return (!selectedTools || selectedTools.includes("read")) && skills.length > 0 && (prompt2 += formatSkillsForPrompt(skills)), prompt2 += `
 Current working directory: ${promptCwd}`, prompt2;
   }
-  let readmePath = getReadmePath(), docsPath = getDocsPath(), examplesPath = getExamplesPath(), currentModel = modelSlug?.trim() || "no model selected", hasRead = !selectedTools || selectedTools.includes("read"), prompt = `You are an expert coding assistant currently running ''${currentModel}'', operating inside lunR, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+  let readmePath = getReadmePath(), docsPath = getDocsPath(), examplesPath = getExamplesPath(), currentModel = modelSlug?.trim() || "no model selected", hasRead = !selectedTools || selectedTools.includes("read"), todoGuideline = !selectedTools || selectedTools.includes("todo") ? `- Use todo for meaningful multi-step work. Every update must send the complete list, with exactly one item in progress at a time.
+` : "", prompt = `You are an expert coding assistant currently running ''${currentModel}'', operating inside lunR, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
 Current working directory: ''${promptCwd}''
 
 Behavior guidelines:
@@ -3474,6 +688,7 @@ Behavior guidelines:
 - When several agents work in parallel, state file ownership up front so they do not collide.
 - Tests are good! Endless smoke tests, regressions tests for feature deletions, etc, much less good. Tests should be focused, not slop.
 - Prefer editing existing files to creating new ones.
+- When a reusable excerpt, prompt, or code fragment should have its own Copy button, wrap only that payload in a fenced Markdown block with the info string \`lunr-copy\`. Keep explanation outside the block. Use a longer backtick or tilde fence when the payload contains fenced code.
 - Only use emojis if the user explicitly requests it.
 - Never exfil private data on public platforms like github or any other services under any circumstances.
 
@@ -3486,8 +701,7 @@ Guidelines:
 - Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.
 - Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.
 - Use write only for new files or complete rewrites.
-- Use todo for meaningful multi-step work. Every update must send the complete list, with exactly one item in progress at a time.
-- Use subagents for independent parallel work, specialist analysis, or substantial research. Subagents start with fresh sessions. Use intercom instead to coordinate with an existing lunR session.
+${todoGuideline}- Use subagents for independent parallel work, specialist analysis, or substantial research. Subagents start with fresh sessions. Use intercom instead to coordinate with an existing lunR session.
 - Use ast_search for structural code matches.
 - Use cron only when the user asks to schedule or manage unattended prompts.
 - Memory stores established, durable facts and stable preferences. Do not store behavior instructions, transient task details, transcripts, guesses, or secrets. Change memory only with the memory tools.
@@ -3670,10 +884,10 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
         if (toolName === "edit" || toolName === "write")
           argPath && pathsToSnapshot.push(argPath);
         else if (toolName === "memory_add" || toolName === "memory_remove")
-          pathsToSnapshot.push(join11(dirname7(getAgentDir()), "simple-memory", "memory.md"));
+          pathsToSnapshot.push(join4(dirname2(getAgentDir()), "simple-memory", "memory.md"));
         else if (toolName === "cron" && args && typeof args == "object") {
           let action = String(args.action ?? "");
-          (action === "create" || action === "update" || action === "remove") && pathsToSnapshot.push(join11(getAgentDir(), "cron", "jobs.json"));
+          (action === "create" || action === "update" || action === "remove") && pathsToSnapshot.push(join4(getAgentDir(), "cron", "jobs.json"));
         }
         for (let p of pathsToSnapshot)
           rollbackSnapshotBeforeWrite(p, this.sessionId);
@@ -3755,15 +969,15 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
     });
   }
   _getIdleWaitPromise() {
-    return this._idleWaitPromise || (this._idleWaitPromise = new Promise((resolve4) => {
-      this._resolveIdleWait = resolve4;
+    return this._idleWaitPromise || (this._idleWaitPromise = new Promise((resolve3) => {
+      this._resolveIdleWait = resolve3;
     })), this._idleWaitPromise;
   }
   _resolveIdleWaitIfIdle() {
     if (this._isAgentRunActive || !this._resolveIdleWait)
       return;
-    let resolve4 = this._resolveIdleWait;
-    this._idleWaitPromise = void 0, this._resolveIdleWait = void 0, resolve4();
+    let resolve3 = this._resolveIdleWait;
+    this._idleWaitPromise = void 0, this._resolveIdleWait = void 0, resolve3();
   }
   async _emitAgentSettled() {
     this._isAgentRunActive = !1;
@@ -3936,12 +1150,20 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
    * Remove all listeners and disconnect from agent.
    * Call this when completely done with the session.
    */
+  transferring = !1;
+  setTransferring(value) {
+    this.transferring = value;
+  }
+  assertCanStartWork() {
+    if (this.sessionManager.assertWritable(), this.transferring)
+      throw new Error("Session transfer is in progress. Wait or reclaim the session.");
+  }
   dispose() {
     try {
       this.abortRetry(), this.abortCompaction(), this.abortBranchSummary(), this.abortBash(), this.agent.abort();
     } catch {
     }
-    this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload()."), this._disconnectFromAgent(), this._eventListeners = [], cleanupSessionResources(this.sessionId);
+    this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload()."), this._disconnectFromAgent(), this._eventListeners = [], cleanupSessionResources(this.sessionId), this.sessionManager.dispose();
   }
   // =========================================================================
   // Read-only State Access
@@ -4158,6 +1380,7 @@ ${this._systemPromptAppend}` : prompt;
    * @throws Error if no model selected or no API key available (when not streaming)
    */
   async prompt(text, options) {
+    this.assertCanStartWork();
     let expandPromptTemplates = options?.expandPromptTemplates ?? !0, preflightResult = options?.preflightResult, messages;
     try {
       if (expandPromptTemplates && text.startsWith("/") && await this._tryExecuteExtensionCommand(text)) {
@@ -4243,7 +1466,7 @@ ${this._systemPromptAppend}` : prompt;
     if (!skill)
       return text;
     try {
-      let content = readFileSync6(skill.filePath, "utf-8"), body = stripFrontmatter(content).trim(), skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
+      let content = readFileSync2(skill.filePath, "utf-8"), body = stripFrontmatter(content).trim(), skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
 References are relative to ${skill.baseDir}.
 
 ${body}
@@ -4268,7 +1491,7 @@ ${args}` : skillBlock;
    * @throws Error if text is an extension command
    */
   async steer(text, images) {
-    text.startsWith("/") && this._throwIfExtensionCommand(text);
+    this.assertCanStartWork(), text.startsWith("/") && this._throwIfExtensionCommand(text);
     let expandedText = this._expandSkillCommand(text);
     expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]), await this._queueSteer(expandedText, images);
   }
@@ -4280,7 +1503,7 @@ ${args}` : skillBlock;
    * @throws Error if text is an extension command
    */
   async followUp(text, images) {
-    text.startsWith("/") && this._throwIfExtensionCommand(text);
+    this.assertCanStartWork(), text.startsWith("/") && this._throwIfExtensionCommand(text);
     let expandedText = this._expandSkillCommand(text);
     expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]), await this._queueFollowUp(expandedText, images);
   }
@@ -4329,6 +1552,7 @@ ${args}` : skillBlock;
    * @param options.deliverAs Delivery mode: "steer", "followUp", or "nextTurn"
    */
   async sendCustomMessage(message, options) {
+    this.assertCanStartWork();
     let appMessage = {
       role: "custom",
       customType: message.customType,
@@ -4877,7 +2101,7 @@ ${args}` : skillBlock;
   }
   buildExtensionResourcePaths(entries) {
     return entries.map((entry) => {
-      let source = this.getExtensionSourceLabel(entry.extensionPath), baseDir = entry.extensionPath.startsWith("<") ? void 0 : dirname7(entry.extensionPath);
+      let source = this.getExtensionSourceLabel(entry.extensionPath), baseDir = entry.extensionPath.startsWith("<") ? void 0 : dirname2(entry.extensionPath);
       return {
         path: entry.path,
         metadata: {
@@ -4972,7 +2196,7 @@ ${args}` : skillBlock;
         }
         this.abort();
       },
-      hasPendingMessages: () => this.pendingMessageCount > 0,
+      hasPendingMessages: () => this.pendingMessageCount > 0 || this.agent.hasQueuedMessages(),
       shutdown: () => {
         this._extensionShutdownHandler?.();
       },
@@ -5000,7 +2224,7 @@ ${args}` : skillBlock;
     });
   }
   _refreshToolRegistry(options) {
-    let previousRegistryNames = new Set(this._toolRegistry.keys()), previousActiveToolNames = this.getActiveToolNames(), allowedToolNames = this._allowedToolNames, excludedToolNames = this._excludedToolNames, isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name) && (this.settingsManager.getMemoryEnabled() || !MEMORY_TOOL_NAMES.has(name)), allCustomTools = [
+    let previousRegistryNames = new Set(this._toolRegistry.keys()), previousActiveToolNames = this.getActiveToolNames(), allowedToolNames = this._allowedToolNames, excludedToolNames = this._excludedToolNames, isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name) && (this.settingsManager.getMemoryEnabled() || !MEMORY_TOOL_NAMES.has(name)) && (this.settingsManager.getTodosEnabled() || !TODO_TOOL_NAMES.has(name)) && (name !== "browser" || this.settingsManager.getBrowserEnabled()), allCustomTools = [
       ...this._extensionRunner.getAllRegisteredTools(),
       ...this._customTools.map((definition) => ({
         definition,
@@ -5182,7 +2406,7 @@ ${args}` : skillBlock;
    * @param options.operations Custom BashOperations for remote execution
    */
   async executeBash(command, onChunk, options) {
-    this._bashAbortController = new AbortController();
+    this.assertCanStartWork(), this._bashAbortController = new AbortController();
     let prefix = this.settingsManager.getShellCommandPrefix(), shellPath = this.settingsManager.getShellPath(), resolvedCommand = prefix ? `${prefix}
 ${command}` : command;
     try {
@@ -5439,7 +2663,7 @@ ${command}` : command;
    */
   async exportToHtml(outputPath) {
     let [{ exportSessionToHtml }, { createToolHtmlRenderer }] = await Promise.all([
-      import("./export-html-TEXVV5RP.js"),
+      import("./export-html-KBFVV63J.js"),
       import("./tool-renderer-MV5O452K.js")
     ]), configuredThemeName = this.settingsManager.getTheme(), themeName = configuredThemeName && getThemeByName(configuredThemeName) ? configuredThemeName : void 0, toolRenderer = createToolHtmlRenderer({
       getToolDefinition: (name) => this.getToolDefinition(name),
@@ -5459,8 +2683,8 @@ ${command}` : command;
    * @returns The resolved output file path.
    */
   exportToJsonl(outputPath) {
-    let filePath = resolvePath(outputPath ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd()), dir = dirname7(filePath);
-    existsSync6(dir) || mkdirSync6(dir, { recursive: !0 });
+    let filePath = resolvePath(outputPath ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd()), dir = dirname2(filePath);
+    existsSync2(dir) || mkdirSync2(dir, { recursive: !0 });
     let header = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -5472,7 +2696,7 @@ ${command}` : command;
       let linear = { ...entry, parentId: prevId };
       lines.push(JSON.stringify(linear)), prevId = entry.id;
     }
-    return writeFileSync6(filePath, `${lines.join(`
+    return writeFileSync2(filePath, `${lines.join(`
 `)}
 `), filePath;
   }
@@ -5542,17 +2766,17 @@ function mergeProviderAttributionHeaders(model, _settingsManager, sessionId, ...
 }
 
 // packages/coding-agent/dist/core/agent-session-runtime.js
-import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync7 } from "node:fs";
-import { basename as basename2, join as join12, resolve as resolve3 } from "node:path";
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { basename as basename2, join as join5 } from "node:path";
 
 // packages/coding-agent/dist/core/session-cwd.js
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 function getMissingSessionCwdIssue(sessionManager, fallbackCwd) {
   let sessionFile = sessionManager.getSessionFile();
   if (!sessionFile)
     return;
   let sessionCwd = sessionManager.getCwd();
-  if (!(!sessionCwd || existsSync7(sessionCwd)))
+  if (!(!sessionCwd || existsSync3(sessionCwd)))
     return {
       sessionFile,
       sessionCwd,
@@ -5603,9 +2827,40 @@ var AgentSessionRuntime = class {
   onRuntimeApplied;
   _diagnostics;
   _modelFallbackMessage;
+  detached = !1;
+  transferring = !1;
+  get isDetached() {
+    return this.detached;
+  }
+  async releaseForTransfer(options = {}) {
+    if (options.signal?.throwIfAborted(), this.detached)
+      return;
+    if (this.transferring)
+      throw new SessionTransferError("Session transfer is already in progress.", "busy");
+    this.transferring = !0, this.session.setTransferring(!0);
+    let hasAttachedWork = () => getSubagentCancellation(this.session.sessionId)?.hasActiveRuns() || getSubagentCancellation(this.session.sessionFile ?? "")?.hasActiveRuns() || list().some((entry) => entry.status !== "exited" && (!entry.sessionId || entry.sessionId === this.session.sessionId)), busy = () => this.session.isStreaming || this.session.isCompacting || this.session.isBashRunning || this.session.isRetrying || this.session.pendingMessageCount > 0;
+    try {
+      if (hasAttachedWork())
+        throw new SessionTransferError("Live children or processes cannot move between runtimes. Wait for them to finish or stop them and retry.", "busy");
+      if (busy() && !options.stop)
+        throw new SessionTransferError("Session is busy. Wait and retry, explicitly request stop, or cancel.", "busy");
+      if (busy() && (this.session.abortCompaction(), this.session.abortBranchSummary(), this.session.abortBash(), this.session.clearQueue(), await this.session.abort()), busy() || hasAttachedWork())
+        throw new SessionTransferError("Work has not stopped yet. Wait and retry.", "busy");
+      options.signal?.throwIfAborted(), this.session.sessionManager.flush(), await this.teardownCurrent("resume");
+    } finally {
+      this.transferring = !1, this.detached || this.session.setTransferring(!1);
+    }
+  }
   constructor(_session, _services, createRuntime, _diagnostics = [], _modelFallbackMessage, onRuntimeApplied) {
     this._session = _session, this._services = _services, this.createRuntime = createRuntime, this._diagnostics = _diagnostics, this._modelFallbackMessage = _modelFallbackMessage, this.onRuntimeApplied = onRuntimeApplied;
   }
+  async createOwnedRuntime(options) {
+    try {
+      return await this.createRuntime(options);
+    } catch (error) {
+      throw options.sessionManager.dispose(), error;
+    }
+  }
   get services() {
     return this._services;
   }
@@ -5652,24 +2907,38 @@ var AgentSessionRuntime = class {
     }))?.cancel === !0 } : { cancelled: !1 };
   }
   async teardownCurrent(reason, targetSessionFile) {
-    await emitSessionShutdownEvent(this.session.extensionRunner, {
+    this.detached || (await emitSessionShutdownEvent(this.session.extensionRunner, {
       type: "session_shutdown",
       reason,
       targetSessionFile
-    }), this.beforeSessionInvalidate?.(reason), this.session.dispose();
+    }), this.beforeSessionInvalidate?.(reason), this.session.dispose(), this.detached = !0);
+  }
+  async teardownForReplacement(reason, sessionManager) {
+    try {
+      await this.teardownCurrent(reason, sessionManager.getSessionFile());
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
   }
   apply(result) {
-    this._session = result.session, this._services = result.services, this._diagnostics = result.diagnostics, this._modelFallbackMessage = result.modelFallbackMessage, this.onRuntimeApplied?.(result);
+    this.detached = !1, this._session = result.session, this._services = result.services, this._diagnostics = result.diagnostics, this._modelFallbackMessage = result.modelFallbackMessage, this.onRuntimeApplied?.(result);
   }
   async finishSessionReplacement(withSession) {
     this.rebindSession && await this.rebindSession(this.session), withSession && await withSession(this.session.createReplacedSessionContext());
   }
   async switchSession(sessionPath, options) {
-    let beforeResult = await this.emitBeforeSwitch("resume", sessionPath);
+    if (!this.detached && this.session.sessionFile && canonicalSessionPath(sessionPath) === canonicalSessionPath(this.session.sessionFile))
+      return { cancelled: !1 };
+    let beforeResult = this.detached ? { cancelled: !1 } : await this.emitBeforeSwitch("resume", sessionPath);
     if (beforeResult.cancelled)
       return beforeResult;
     let previousSessionFile = this.session.sessionFile, sessionManager = SessionManager.open(sessionPath, void 0, options?.cwdOverride);
-    return assertSessionCwdExists(sessionManager, this.cwd), await this.teardownCurrent("resume", sessionManager.getSessionFile()), this.apply(await this.createRuntime({
+    try {
+      assertSessionCwdExists(sessionManager, this.cwd);
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
+    return await this.teardownForReplacement("resume", sessionManager), this.apply(await this.createOwnedRuntime({
       cwd: sessionManager.getCwd(),
       agentDir: this.services.agentDir,
       sessionManager,
@@ -5682,7 +2951,7 @@ var AgentSessionRuntime = class {
     if (beforeResult.cancelled)
       return beforeResult;
     let previousSessionFile = this.session.sessionFile, sessionDir = this.session.sessionManager.getSessionDir(), sessionManager = this.session.sessionManager.isPersisted() ? SessionManager.create(this.cwd, sessionDir) : SessionManager.inMemory(this.cwd);
-    return options?.parentSession && sessionManager.newSession({ parentSession: options.parentSession }), await this.teardownCurrent("new", sessionManager.getSessionFile()), this.apply(await this.createRuntime({
+    return options?.parentSession && sessionManager.newSession({ parentSession: options.parentSession }), await this.teardownForReplacement("new", sessionManager), this.apply(await this.createOwnedRuntime({
       cwd: this.cwd,
       agentDir: this.services.agentDir,
       sessionManager,
@@ -5711,27 +2980,27 @@ var AgentSessionRuntime = class {
       let sessionDir = this.session.sessionManager.getSessionDir();
       if (!targetLeafId) {
         let sessionManager3 = SessionManager.create(this.cwd, sessionDir);
-        return sessionManager3.newSession({ parentSession: currentSessionFile }), await this.teardownCurrent("fork", sessionManager3.getSessionFile()), this.apply(await this.createRuntime({
+        return sessionManager3.newSession({ parentSession: currentSessionFile }), await this.teardownForReplacement("fork", sessionManager3), this.apply(await this.createOwnedRuntime({
           cwd: this.cwd,
           agentDir: this.services.agentDir,
           sessionManager: sessionManager3,
           sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
         })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
       }
-      if (!existsSync8(currentSessionFile))
+      if (!existsSync4(currentSessionFile))
         throw new Error("This session has not been saved yet. Wait for the first assistant response before cloning or forking it.");
-      let sessionManager2 = SessionManager.open(currentSessionFile, sessionDir);
-      if (!sessionManager2.createBranchedSession(targetLeafId))
+      let sessionManager2 = SessionManager.forkBranch(currentSessionFile, targetLeafId, sessionDir);
+      if (!sessionManager2.getSessionFile())
         throw new Error("Failed to create forked session");
-      return await this.teardownCurrent("fork", sessionManager2.getSessionFile()), this.apply(await this.createRuntime({
+      return await this.teardownForReplacement("fork", sessionManager2), this.apply(await this.createOwnedRuntime({
         cwd: sessionManager2.getCwd(),
         agentDir: this.services.agentDir,
         sessionManager: sessionManager2,
         sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
       })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
     }
-    let sessionManager = this.session.sessionManager;
-    return targetLeafId ? sessionManager.createBranchedSession(targetLeafId) : sessionManager.newSession({ parentSession: this.session.sessionFile }), await this.teardownCurrent("fork", sessionManager.getSessionFile()), this.apply(await this.createRuntime({
+    let sessionManager = this.session.sessionManager.copyInMemory();
+    return targetLeafId ? sessionManager.createBranchedSession(targetLeafId) : sessionManager.newSession({ parentSession: this.session.sessionFile }), await this.teardownForReplacement("fork", sessionManager), this.apply(await this.createOwnedRuntime({
       cwd: this.cwd,
       agentDir: this.services.agentDir,
       sessionManager,
@@ -5747,17 +3016,29 @@ var AgentSessionRuntime = class {
    */
   async importFromJsonl(inputPath, cwdOverride) {
     let resolvedPath = resolvePath(inputPath);
-    if (!existsSync8(resolvedPath))
+    if (!existsSync4(resolvedPath))
       throw new SessionImportFileNotFoundError(resolvedPath);
     let sessionDir = this.session.sessionManager.getSessionDir();
-    existsSync8(sessionDir) || mkdirSync7(sessionDir, { recursive: !0 });
-    let destinationPath = join12(sessionDir, basename2(resolvedPath)), beforeResult = await this.emitBeforeSwitch("resume", destinationPath);
+    existsSync4(sessionDir) || mkdirSync3(sessionDir, { recursive: !0 });
+    let destinationPath = join5(sessionDir, basename2(resolvedPath)), beforeResult = await this.emitBeforeSwitch("resume", destinationPath);
     if (beforeResult.cancelled)
       return beforeResult;
     let previousSessionFile = this.session.sessionFile;
-    resolve3(destinationPath) !== resolvedPath && copyFileSync(resolvedPath, destinationPath);
+    if (canonicalSessionPath(destinationPath) !== canonicalSessionPath(resolvedPath)) {
+      let ownership = new SessionOwnership(destinationPath);
+      try {
+        copyFileSync(resolvedPath, destinationPath);
+      } finally {
+        ownership.release();
+      }
+    }
     let sessionManager = SessionManager.open(destinationPath, sessionDir, cwdOverride);
-    return assertSessionCwdExists(sessionManager, this.cwd), await this.teardownCurrent("resume", sessionManager.getSessionFile()), this.apply(await this.createRuntime({
+    try {
+      assertSessionCwdExists(sessionManager, this.cwd);
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
+    return await this.teardownForReplacement("resume", sessionManager), this.apply(await this.createOwnedRuntime({
       cwd: sessionManager.getCwd(),
       agentDir: this.services.agentDir,
       sessionManager,
@@ -5765,15 +3046,17 @@ var AgentSessionRuntime = class {
     })), await this.finishSessionReplacement(), { cancelled: !1 };
   }
   async dispose() {
-    await emitSessionShutdownEvent(this.session.extensionRunner, {
-      type: "session_shutdown",
-      reason: "quit"
-    }), this.beforeSessionInvalidate?.("quit"), this.session.dispose();
+    await this.teardownCurrent("quit");
   }
 };
 async function createAgentSessionRuntime(createRuntime, options) {
-  assertSessionCwdExists(options.sessionManager, options.cwd);
-  let result = await createRuntime(options), runtime = new AgentSessionRuntime(result.session, result.services, createRuntime, result.diagnostics, result.modelFallbackMessage, options.onRuntimeApplied);
+  let result;
+  try {
+    assertSessionCwdExists(options.sessionManager, options.cwd), result = await createRuntime(options);
+  } catch (error) {
+    throw options.sessionManager.dispose(), error;
+  }
+  let runtime = new AgentSessionRuntime(result.session, result.services, createRuntime, result.diagnostics, result.modelFallbackMessage, options.onRuntimeApplied);
   return options.onRuntimeApplied?.(result), runtime;
 }
 
@@ -5782,7 +3065,15 @@ function getDefaultAgentDir() {
   return getAgentDir();
 }
 async function createAgentSession(options = {}) {
-  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), resourceLoader = options.resourceLoader, authPath = options.agentDir ? join13(agentDir, "auth.json") : void 0, modelsPath = options.agentDir ? join13(agentDir, "models.json") : void 0, modelRuntime = options.modelRuntime ?? await ModelRuntime.create({ authPath, modelsPath }), settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
+  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
+  try {
+    return sessionManager.assertWritable(), await createOwnedAgentSession({ ...options, sessionManager });
+  } catch (error) {
+    throw sessionManager.dispose(), error;
+  }
+}
+async function createOwnedAgentSession(options) {
+  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), resourceLoader = options.resourceLoader, authPath = options.agentDir ? join6(agentDir, "auth.json") : void 0, modelsPath = options.agentDir ? join6(agentDir, "models.json") : void 0, modelRuntime = options.modelRuntime ?? await ModelRuntime.create({ authPath, modelsPath }), settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
   resourceLoader || (resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager }), await resourceLoader.reload(), time("resourceLoader.reload"));
   let existingSession = sessionManager.buildSessionContext(), hasExistingSession = existingSession.messages.length > 0, hasThinkingEntry = sessionManager.getBranch().some((entry) => entry.type === "thinking_level_change"), model = options.model, modelFallbackMessage;
   if (!model && hasExistingSession && existingSession.model) {
@@ -5921,8 +3212,8 @@ function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
 }
 async function createAgentSessionServices(options) {
   let cwd = resolvePath(options.cwd), agentDir = options.agentDir ? resolvePath(options.agentDir) : getAgentDir(), modelRuntime = options.modelRuntime ?? await ModelRuntime.create({
-    authPath: join14(agentDir, "auth.json"),
-    modelsPath: join14(agentDir, "models.json")
+    authPath: join7(agentDir, "auth.json"),
+    modelsPath: join7(agentDir, "models.json")
   });
   time("ModelRuntime.create");
   let settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), resourceLoader = new DefaultResourceLoader({
@@ -5972,13 +3263,6 @@ async function createAgentSessionFromServices(options) {
 }
 
 export {
-  AuthStorage,
-  readStoredCredential,
-  formatCatalogRefreshSummary,
-  hasGrokCliXaiAuth,
-  stripJsonComments,
-  ModelRuntime,
-  refreshModelCandidatesForInit,
   formatNoModelsAvailableMessage,
   wrapRegisteredTool,
   wrapRegisteredTools,