unrestricted 1.0.0 → 1.1.0

package/dist/unrestricted.mjs

@@ -12,6 +12,10 @@ var __commonJS = (cb, mod) => function __require() {
     throw mod = 0, e2;
   }
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -489,6 +493,23 @@ var x = class {
     }
   }
 };
+var dD = class extends x {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(u2) {
+    super(u2, false), this.value = !!u2.initialValue, this.on("value", () => {
+      this.value = this._value;
+    }), this.on("confirm", (t) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = t, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
 var A;
 A = /* @__PURE__ */ new WeakMap();
 var kD = Object.defineProperty;
@@ -580,6 +601,25 @@ var G2 = (t) => {
     return j2 || E ? import_picocolors.default.dim("...") : i(p2, v + l2 === n);
   });
 };
+var ye = (t) => {
+  const n = t.active ?? "Yes", r2 = t.inactive ?? "No";
+  return new dD({ active: n, inactive: r2, initialValue: t.initialValue ?? true, render() {
+    const i = `${import_picocolors.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`, s = this.value ? n : r2;
+    switch (this.state) {
+      case "submit":
+        return `${i}${import_picocolors.default.gray(o)}  ${import_picocolors.default.dim(s)}`;
+      case "cancel":
+        return `${i}${import_picocolors.default.gray(o)}  ${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}
+${import_picocolors.default.gray(o)}`;
+      default:
+        return `${i}${import_picocolors.default.cyan(o)}  ${this.value ? `${import_picocolors.default.green(k2)} ${n}` : `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(n)}`} ${import_picocolors.default.dim("/")} ${this.value ? `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(r2)}` : `${import_picocolors.default.green(k2)} ${r2}`}
+${import_picocolors.default.cyan(d2)}
+`;
+    }
+  } }).prompt();
+};
 var fe = (t) => {
   const n = (r2, i) => {
     const s = r2.label ?? String(r2.value);
@@ -724,13 +764,11 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 
 // cli/src/command.ts
 var FAILED = { code: 1 };
+var NOTHING_CHANGED = "Nothing changed.";
 function reason(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// cli/src/writers/json-file.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-
 // cli/src/text-file.ts
 var BOM = "\uFEFF";
 var NEW_FILE = { eol: "\n", bom: false };
@@ -752,19 +790,375 @@ function fromLf(text, layout) {
   return withBom(layout.eol === "\n" ? text : text.replace(/\r?\n/g, "\r\n"), layout);
 }
 
+// cli/src/writers/tool-file.ts
+import { readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+
+// cli/src/backup.ts
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+
+// cli/src/config.ts
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+var THIS_MACHINE = { platform: process.platform, homedir };
+var AUTO_UPDATE_TOOLS = ["opencode", "pi"];
+var ALL_TOOLS = ["opencode", "codex", "qwen-code", "goose", "openhands", "aider", "continue", "crush", "pi", "claude"];
+var DISABLED_TOOLS = /* @__PURE__ */ new Set(["aider", "claude"]);
+var OFFERED_TOOLS = ALL_TOOLS.filter((tool) => !DISABLED_TOOLS.has(tool));
+var TOOL_LABELS = {
+  opencode: "OpenCode",
+  codex: "Codex CLI",
+  "qwen-code": "Qwen Code",
+  goose: "Goose",
+  openhands: "OpenHands",
+  aider: "Aider",
+  continue: "Continue",
+  crush: "Crush",
+  pi: "Pi",
+  claude: "Claude Code"
+};
+var SETUP_INTRO = "unrestricted.sh setup";
+var SETUP_OUTRO = "Done.";
+var WINDOWS_PLATFORM = "win32";
+var CONFIG_HOME_DIR = ".config";
+var OPENCODE_CONFIG_DIR = "opencode";
+var OPENCODE_CONFIG_FILE = "opencode.json";
+var OPENCODE_JSONC_FILE = "opencode.jsonc";
+var AIDER_CONFIG_FILE = ".aider.conf.yml";
+var CONTINUE_CONFIG_DIR = ".continue";
+var CONTINUE_CONFIG_FILE = "config.yaml";
+var CRUSH_CONFIG_DIR = "crush";
+var CRUSH_CONFIG_FILE = "crushrc";
+var PI_AGENT_DIR = ".pi/agent";
+var PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+var PI_MODELS_FILE = "models.json";
+var PI_SETTINGS_FILE = "settings.json";
+var PI_API = "openai-completions";
+var PI_THINKING_LEVEL_MAP = { off: "none", minimal: null, low: "low", medium: "medium", high: "xhigh" };
+var CODEX_CONFIG_DIR = ".codex";
+var CODEX_CONFIG_FILE = "config.toml";
+var QWEN_CONFIG_DIR = ".qwen";
+var QWEN_SETTINGS_FILE = "settings.json";
+var GOOSE_CONFIG_DIR = "goose";
+var GOOSE_WINDOWS_CONFIG_DIR = "Block/goose/config";
+var GOOSE_CONFIG_FILE = "config.yaml";
+var GOOSE_CUSTOM_PROVIDERS_DIR = "custom_providers";
+var OPENHANDS_CONFIG_DIR = ".openhands";
+var OPENHANDS_SETTINGS_FILE = "agent_settings.json";
+var WINDOWS_APP_DATA_ENV = "APPDATA";
+var WINDOWS_APP_DATA_DIR = "AppData/Roaming";
+var DEFAULT_BASE_URL = "https://api.unrestricted.sh/v1";
+var DEFAULT_ORIGIN = "https://unrestricted.sh";
+var DEFAULT_MODEL = "qwen3.8-27b-uncensored";
+var DEFAULT_MODEL_NAME = "Qwen3.8 27B Uncensored";
+var PREVIOUS_DEFAULT_MODELS = ["abliterated-model"];
+var CONTEXT = 262144;
+var MAX_OUTPUT = 32768;
+var PROVIDER = "unrestricted";
+var PROVIDER_NAME = "unrestricted.sh";
+var API_KEY_ENV = "UNRESTRICTED_API_KEY";
+var KEY_PREFIX = "unr_sk_";
+var KEY_LENGTH = 39;
+var KEY_ERROR = `UNRESTRICTED_API_KEY is not an ${KEY_PREFIX} key. Leave it unset to approve the connection in the browser instead.`;
+function keyAcceptedMessage(base) {
+  return `Key accepted by ${base}`;
+}
+function piModel(id, name, context, maxOutput) {
+  return {
+    id,
+    name,
+    reasoning: true,
+    thinkingLevelMap: PI_THINKING_LEVEL_MAP,
+    input: ["text"],
+    contextWindow: context,
+    maxTokens: maxOutput
+  };
+}
+function isOwnModel(model, owner) {
+  return model === owner.model || model === DEFAULT_MODEL || PREVIOUS_DEFAULT_MODELS.includes(model) || owner.models.some((listed) => listed.id === model);
+}
+function isOwnDefault(value, owner) {
+  const prefix = `${owner.provider}/`;
+  return value.startsWith(prefix) && isOwnModel(value.slice(prefix.length), owner);
+}
+function disabledToolMessage(tool, origin) {
+  if (tool === "aider") return `${TOOL_LABELS.aider} is no longer set up by unrestricted.sh. See ${origin}/guides/aider to set it up by hand`;
+  return `${TOOL_LABELS[tool]} is not available yet`;
+}
+function isToolId(value) {
+  return ALL_TOOLS.includes(value);
+}
+function isAutoUpdateTool(tool) {
+  return AUTO_UPDATE_TOOLS.includes(tool);
+}
+function parseTools(value) {
+  const tools = [];
+  const unknown = [];
+  const disabled = [];
+  for (const entry of value.split(",")) {
+    const name = entry.trim();
+    if (!name) continue;
+    if (!isToolId(name)) unknown.push(name);
+    else if (DISABLED_TOOLS.has(name)) disabled.push(name);
+    else tools.push(name);
+  }
+  return { tools, unknown, disabled };
+}
+function stripTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function pathsFor(platform) {
+  return platform === WINDOWS_PLATFORM ? win32 : posix;
+}
+function windowsShellPath(dir) {
+  if (!dir.startsWith("/") || dir.startsWith("//") || dir.includes("\\")) return dir;
+  const drive = /^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i.exec(dir);
+  if (drive === null) return dir;
+  return `${drive[1].toUpperCase()}:\\${(drive[2] ?? "").replaceAll("/", "\\")}`;
+}
+function resolvePiAgentDir(env, home, platform) {
+  const { join: join4 } = pathsFor(platform);
+  const set = env[PI_AGENT_DIR_ENV];
+  if (!set) return join4(home, ...PI_AGENT_DIR.split("/"));
+  const windows = platform === WINDOWS_PLATFORM;
+  const dir = windows ? windowsShellPath(set) : set;
+  if (dir === "~") return home;
+  if (dir.startsWith("~/") || windows && dir.startsWith("~\\")) return join4(home, dir.slice(2));
+  return dir;
+}
+function windowsVariable(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+  return key === void 0 ? void 0 : env[key];
+}
+function windowsAppData(env, home) {
+  return windowsVariable(env, WINDOWS_APP_DATA_ENV) || win32.join(home, ...WINDOWS_APP_DATA_DIR.split("/"));
+}
+function resolveGooseConfigDir(env, home, configHome, platform) {
+  if (platform !== WINDOWS_PLATFORM) return posix.join(configHome, GOOSE_CONFIG_DIR);
+  return win32.join(windowsAppData(env, home), ...GOOSE_WINDOWS_CONFIG_DIR.split("/"));
+}
+function homeOf(env, machine) {
+  if (env.HOME) return env.HOME;
+  try {
+    return machine.homedir();
+  } catch {
+    return "";
+  }
+}
+function readConfig(env, machine = THIS_MACHINE) {
+  const key = env.UNRESTRICTED_API_KEY ?? "";
+  if (key && !key.startsWith(KEY_PREFIX)) throw new Error(KEY_ERROR);
+  if (key && key.length !== KEY_LENGTH) throw new Error("UNRESTRICTED_API_KEY has the wrong length");
+  const home = homeOf(env, machine);
+  if (!home) throw new Error("HOME is not set and the home directory could not be found");
+  const { join: join4 } = pathsFor(machine.platform);
+  const model = env.UNRESTRICTED_MODEL || DEFAULT_MODEL;
+  const modelName = env.UNRESTRICTED_MODEL_NAME || DEFAULT_MODEL_NAME;
+  const configHome = env.XDG_CONFIG_HOME || join4(home, CONFIG_HOME_DIR);
+  return {
+    key: key || null,
+    base: env.UNRESTRICTED_BASE_URL || DEFAULT_BASE_URL,
+    origin: stripTrailingSlashes(env.UNRESTRICTED_ORIGIN || env.UNRESTRICTED_SETUP_ORIGIN || DEFAULT_ORIGIN),
+    model,
+    modelName,
+    context: CONTEXT,
+    maxOutput: MAX_OUTPUT,
+    models: [{ id: model, name: modelName, context: CONTEXT, maxOutput: MAX_OUTPUT }],
+    provider: PROVIDER,
+    platform: machine.platform,
+    home,
+    configHome,
+    piAgentDir: resolvePiAgentDir(env, home, machine.platform),
+    gooseConfigDir: resolveGooseConfigDir(env, home, configHome, machine.platform)
+  };
+}
+
+// cli/src/file-mode.ts
+import { chmodSync } from "node:fs";
+var WINDOWS = "win32";
+function setMode(path, mode, platform = process.platform) {
+  if (platform === WINDOWS) return;
+  chmodSync(path, mode);
+}
+
+// cli/src/paths.ts
+var GOOSE_PROVIDER_FILE = `${PROVIDER}.json`;
+var CLAUDE_CONFIG_DIR = ".claude";
+var CLAUDE_SETTINGS_FILE = "settings.json";
+var CLAUDE_SESSION_FILE = "claude-settings.json";
+var CLAUDE_LAUNCHER = "claude-unrestricted";
+var STORE_DIR_NAME = "unrestricted";
+var OPENCODE_PLUGINS_DIR = "plugins";
+var PI_EXTENSIONS_DIR = "extensions";
+var AUTO_UPDATE_FILE = "unrestricted.ts";
+function tildePath(path, home, platform) {
+  const { sep } = pathsFor(platform);
+  if (home === "" || home.endsWith(sep)) return path;
+  if (path === home) return "~";
+  return path.startsWith(`${home}${sep}`) ? `~${sep}${path.slice(home.length + sep.length)}` : path;
+}
+function toolPaths(locations) {
+  const { join: join4 } = pathsFor(locations.platform);
+  const { home, configHome, piAgentDir, gooseConfigDir: gooseDir } = locations;
+  const opencodeDir = join4(configHome, OPENCODE_CONFIG_DIR);
+  const crushDir = join4(configHome, CRUSH_CONFIG_DIR);
+  const continueDir = join4(home, CONTINUE_CONFIG_DIR);
+  const codexDir = join4(home, CODEX_CONFIG_DIR);
+  const qwenDir = join4(home, QWEN_CONFIG_DIR);
+  const openhandsDir = join4(home, OPENHANDS_CONFIG_DIR);
+  const claudeDir = join4(home, CLAUDE_CONFIG_DIR);
+  const claudeLauncherDir = join4(home, ".local", "bin");
+  return {
+    opencodeDir,
+    opencodeJson: join4(opencodeDir, OPENCODE_CONFIG_FILE),
+    opencodeJsonc: join4(opencodeDir, OPENCODE_JSONC_FILE),
+    opencodePlugin: join4(opencodeDir, OPENCODE_PLUGINS_DIR, AUTO_UPDATE_FILE),
+    crushDir,
+    crushrc: join4(crushDir, CRUSH_CONFIG_FILE),
+    piAgentDir,
+    piModels: join4(piAgentDir, PI_MODELS_FILE),
+    piSettings: join4(piAgentDir, PI_SETTINGS_FILE),
+    piExtension: join4(piAgentDir, PI_EXTENSIONS_DIR, AUTO_UPDATE_FILE),
+    continueDir,
+    continueConfig: join4(continueDir, CONTINUE_CONFIG_FILE),
+    aiderConfig: join4(home, AIDER_CONFIG_FILE),
+    codexDir,
+    codexConfig: join4(codexDir, CODEX_CONFIG_FILE),
+    qwenDir,
+    qwenSettings: join4(qwenDir, QWEN_SETTINGS_FILE),
+    gooseDir,
+    gooseConfig: join4(gooseDir, GOOSE_CONFIG_FILE),
+    gooseProvider: join4(gooseDir, GOOSE_CUSTOM_PROVIDERS_DIR, GOOSE_PROVIDER_FILE),
+    openhandsDir,
+    openhandsSettings: join4(openhandsDir, OPENHANDS_SETTINGS_FILE),
+    claudeDir,
+    claudeGlobalSettings: join4(claudeDir, CLAUDE_SETTINGS_FILE),
+    claudeSessionSettings: join4(configHome, STORE_DIR_NAME, CLAUDE_SESSION_FILE),
+    claudeLauncherDir,
+    claudeLauncher: join4(claudeLauncherDir, CLAUDE_LAUNCHER)
+  };
+}
+
+// cli/src/backup.ts
+var BACKUPS_DIR_NAME = "backups";
+var BACKUPS_KEPT = 5;
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var STAMP = /^\d{8}T\d{6}Z$/;
+var backupsTaken = 0;
+function backupsDir(place) {
+  return pathsFor(place.platform).join(place.configHome, STORE_DIR_NAME, BACKUPS_DIR_NAME);
+}
+function backupStamp(date) {
+  return date.toISOString().replace(/\.\d+Z$/, "Z").replace(/[-:]/g, "");
+}
+function toolBackupsDir(place, tool) {
+  return pathsFor(place.platform).join(backupsDir(place), tool);
+}
+function isExisting(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function makePrivateDir(dir, platform) {
+  mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+  setMode(dir, DIR_MODE, platform);
+}
+function backupsOf(place, tool, file) {
+  const { basename, join: join4 } = pathsFor(place.platform);
+  const dir = toolBackupsDir(place, tool);
+  const prefix = `${basename(file)}.`;
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => name.startsWith(prefix) && STAMP.test(name.slice(prefix.length))).sort().map((name) => join4(dir, name));
+}
+function newestBackup(place, tool, file) {
+  return backupsOf(place, tool, file).at(-1) ?? null;
+}
+function backUp(place, tool, file, now = /* @__PURE__ */ new Date()) {
+  const { basename, join: join4 } = pathsFor(place.platform);
+  const dir = toolBackupsDir(place, tool);
+  for (const parent of [join4(place.configHome, STORE_DIR_NAME), backupsDir(place), dir]) makePrivateDir(parent, place.platform);
+  const target = join4(dir, `${basename(file)}.${backupStamp(now)}`);
+  try {
+    writeFileSync(target, readFileSync(file), { mode: FILE_MODE, flag: "wx" });
+  } catch (error) {
+    if (!isExisting(error)) throw error;
+  }
+  setMode(target, FILE_MODE, place.platform);
+  for (const older of backupsOf(place, tool, file).slice(0, -BACKUPS_KEPT)) rmSync(older, { force: true });
+  backupsTaken += 1;
+  return target;
+}
+function backupsMade() {
+  return backupsTaken;
+}
+function backupsLine(place) {
+  return `Backups of the changed files: ${tildePath(backupsDir(place), place.home, place.platform)}`;
+}
+
+// cli/src/writers/tool-file.ts
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function readText(file) {
+  try {
+    return readFileSync2(file, "utf8");
+  } catch (error) {
+    if (isMissing(error)) return null;
+    throw error;
+  }
+}
+function saveText(place, tool, file, text, current) {
+  if (current === text) return false;
+  if (current !== null) backUp(place, tool, file);
+  writeFileSync2(file, text);
+  return true;
+}
+function deleteText(place, tool, file) {
+  if (readText(file) === null) return false;
+  backUp(place, tool, file);
+  rmSync2(file, { force: true });
+  return true;
+}
+function applyChanges(place, tool, changes) {
+  for (const change of changes) {
+    if (change.next === null) deleteText(place, tool, change.file);
+    else saveText(place, tool, change.file, change.next, change.raw);
+  }
+}
+function splitLines(content) {
+  if (content === "") return [];
+  return (content.endsWith("\n") ? content.slice(0, -1) : content).split("\n");
+}
+function isBlankText(text) {
+  return text.trim() === "";
+}
+
 // cli/src/writers/json-file.ts
 function asObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 function readJsonDocument(file) {
-  if (!existsSync(file)) writeFileSync(file, "{}\n");
-  const raw = readFileSync(file, "utf8");
+  const raw = readText(file);
+  if (raw === null) return { value: {}, layout: NEW_FILE, raw };
   const text = toLf(raw).trim();
-  return { value: text ? asObject(JSON.parse(text)) : {}, layout: layoutOf(raw) };
+  return { value: text ? asObject(JSON.parse(text)) : {}, layout: layoutOf(raw), raw };
+}
+function jsonText(value, layout = NEW_FILE) {
+  return fromLf(`${JSON.stringify(value, null, 2)}
+`, layout);
 }
-function writeJsonDocument(file, value, layout = NEW_FILE) {
-  writeFileSync(file, fromLf(`${JSON.stringify(value, null, 2)}
-`, layout));
+function isBareDocument(value) {
+  return Object.keys(value).every((key) => key === "$schema");
 }
 
 // cli/src/models.ts
@@ -868,180 +1262,42 @@ async function verifyKey(base, key) {
     if (!response.ok) throw new Error(`the key was rejected by ${url}`);
     return parseModelList(await readJson(response));
   } finally {
-    clearTimeout(timer);
-  }
-}
-async function fetchModelCatalog(base, timeoutMs = TIMEOUT_MS) {
-  const url = `${base}/models`;
-  const answer = await getJson(url, { accept: "application/json" }, timeoutMs);
-  if (!answer.ok) throw new Error(`${url} answered ${answer.status}.`);
-  return parseModelCatalog(answer.body);
-}
-function parsePlan(value) {
-  if (value === null) return null;
-  if (typeof value !== "object" || Array.isArray(value)) return void 0;
-  const { name, allowance_usd: allowanceUsd, used_usd: usedUsd, renews_at: renews } = asObject(value);
-  const planName = printable(name, PLAN_NAME_MAX_LENGTH);
-  const renewsAt = typeof renews === "string" ? new Date(renews) : null;
-  if (planName === null || !isAmount(allowanceUsd) || !isAmount(usedUsd) || renewsAt === null || Number.isNaN(renewsAt.getTime())) {
-    return void 0;
-  }
-  return { name: planName, allowanceUsd, usedUsd, renewsAt };
-}
-function parseAccount(body) {
-  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
-  const { balance_usd: balanceUsd, plan, month_spend_usd: monthSpendUsd, api_locked: apiLocked } = asObject(body);
-  const parsedPlan = parsePlan(plan);
-  if (!isAmount(balanceUsd) || !isAmount(monthSpendUsd) || typeof apiLocked !== "boolean" || parsedPlan === void 0) return null;
-  return { balanceUsd, plan: parsedPlan, monthSpendUsd, apiLocked };
-}
-async function fetchAccount(base, key) {
-  const url = `${base}/account`;
-  const answer = await getJson(url, { Authorization: `Bearer ${key}`, accept: "application/json" }, TIMEOUT_MS);
-  if (answer.status === 401) throw new Error('The key was rejected. Run "unrestricted login" to sign in again.');
-  if (answer.status === 403) throw new Error(errorMessage(answer.body) ?? `${url} refused the key.`);
-  if (!answer.ok) throw new Error(`${url} answered ${answer.status}.`);
-  const account = parseAccount(answer.body);
-  if (account === null) throw new Error(`Unexpected answer from ${url}.`);
-  return account;
-}
-
-// cli/src/config.ts
-import { homedir } from "node:os";
-import { posix, win32 } from "node:path";
-var THIS_MACHINE = { platform: process.platform, homedir };
-var AUTO_UPDATE_TOOLS = ["opencode", "pi"];
-var ALL_TOOLS = ["opencode", "codex", "aider", "continue", "crush", "pi", "claude"];
-var DISABLED_TOOLS = /* @__PURE__ */ new Set(["codex", "claude"]);
-var OFFERED_TOOLS = ALL_TOOLS.filter((tool) => !DISABLED_TOOLS.has(tool));
-var TOOL_LABELS = {
-  opencode: "OpenCode",
-  codex: "Codex CLI",
-  aider: "Aider",
-  continue: "Continue",
-  crush: "Crush",
-  pi: "Pi",
-  claude: "Claude Code"
-};
-var SETUP_INTRO = "unrestricted.sh setup";
-var SETUP_OUTRO = "Done.";
-var WINDOWS_PLATFORM = "win32";
-var CONFIG_HOME_DIR = ".config";
-var OPENCODE_CONFIG_DIR = "opencode";
-var OPENCODE_CONFIG_FILE = "opencode.json";
-var OPENCODE_JSONC_FILE = "opencode.jsonc";
-var AIDER_CONFIG_FILE = ".aider.conf.yml";
-var CONTINUE_CONFIG_DIR = ".continue";
-var CONTINUE_CONFIG_FILE = "config.yaml";
-var CRUSH_CONFIG_DIR = "crush";
-var CRUSH_CONFIG_FILE = "crushrc";
-var PI_AGENT_DIR = ".pi/agent";
-var PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
-var PI_MODELS_FILE = "models.json";
-var PI_SETTINGS_FILE = "settings.json";
-var PI_API = "openai-completions";
-var PI_THINKING_LEVEL_MAP = { off: "none", minimal: null, low: "low", medium: "medium", high: "xhigh" };
-var DEFAULT_BASE_URL = "https://api.unrestricted.sh/v1";
-var DEFAULT_ORIGIN = "https://unrestricted.sh";
-var DEFAULT_MODEL = "qwen3.8-27b-uncensored";
-var DEFAULT_MODEL_NAME = "Qwen3.8 27B Uncensored";
-var PREVIOUS_DEFAULT_MODELS = ["abliterated-model"];
-var CONTEXT = 262144;
-var MAX_OUTPUT = 32768;
-var PROVIDER = "unrestricted";
-var KEY_PREFIX = "unr_sk_";
-var KEY_LENGTH = 39;
-var KEY_ERROR = `UNRESTRICTED_API_KEY is not an ${KEY_PREFIX} key. Leave it unset to approve the connection in the browser instead.`;
-function keyAcceptedMessage(base) {
-  return `Key accepted by ${base}`;
-}
-function piModel(id, name, context, maxOutput) {
-  return {
-    id,
-    name,
-    reasoning: true,
-    thinkingLevelMap: PI_THINKING_LEVEL_MAP,
-    input: ["text"],
-    contextWindow: context,
-    maxTokens: maxOutput
-  };
-}
-function isOwnModel(model, config) {
-  return model === config.model || model === DEFAULT_MODEL || PREVIOUS_DEFAULT_MODELS.includes(model) || config.models.some((listed) => listed.id === model);
-}
-function isToolId(value) {
-  return ALL_TOOLS.includes(value);
-}
-function isAutoUpdateTool(tool) {
-  return AUTO_UPDATE_TOOLS.includes(tool);
-}
-function parseTools(value) {
-  const tools = [];
-  const unknown = [];
-  const disabled = [];
-  for (const entry of value.split(",")) {
-    const name = entry.trim();
-    if (!name) continue;
-    if (!isToolId(name)) unknown.push(name);
-    else if (DISABLED_TOOLS.has(name)) disabled.push(name);
-    else tools.push(name);
+    clearTimeout(timer);
   }
-  return { tools, unknown, disabled };
-}
-function stripTrailingSlashes(value) {
-  return value.replace(/\/+$/, "");
-}
-function pathsFor(platform) {
-  return platform === WINDOWS_PLATFORM ? win32 : posix;
 }
-function windowsShellPath(dir) {
-  if (!dir.startsWith("/") || dir.startsWith("//") || dir.includes("\\")) return dir;
-  const drive = /^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i.exec(dir);
-  if (drive === null) return dir;
-  return `${drive[1].toUpperCase()}:\\${(drive[2] ?? "").replaceAll("/", "\\")}`;
-}
-function resolvePiAgentDir(env, home, platform) {
-  const { join: join4 } = pathsFor(platform);
-  const set = env[PI_AGENT_DIR_ENV];
-  if (!set) return join4(home, ...PI_AGENT_DIR.split("/"));
-  const windows = platform === WINDOWS_PLATFORM;
-  const dir = windows ? windowsShellPath(set) : set;
-  if (dir === "~") return home;
-  if (dir.startsWith("~/") || windows && dir.startsWith("~\\")) return join4(home, dir.slice(2));
-  return dir;
+async function fetchModelCatalog(base, timeoutMs = TIMEOUT_MS) {
+  const url = `${base}/models`;
+  const answer = await getJson(url, { accept: "application/json" }, timeoutMs);
+  if (!answer.ok) throw new Error(`${url} answered ${answer.status}.`);
+  return parseModelCatalog(answer.body);
 }
-function homeOf(env, machine) {
-  if (env.HOME) return env.HOME;
-  try {
-    return machine.homedir();
-  } catch {
-    return "";
+function parsePlan(value) {
+  if (value === null) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return void 0;
+  const { name, allowance_usd: allowanceUsd, used_usd: usedUsd, renews_at: renews } = asObject(value);
+  const planName = printable(name, PLAN_NAME_MAX_LENGTH);
+  const renewsAt = typeof renews === "string" ? new Date(renews) : null;
+  if (planName === null || !isAmount(allowanceUsd) || !isAmount(usedUsd) || renewsAt === null || Number.isNaN(renewsAt.getTime())) {
+    return void 0;
   }
+  return { name: planName, allowanceUsd, usedUsd, renewsAt };
 }
-function readConfig(env, machine = THIS_MACHINE) {
-  const key = env.UNRESTRICTED_API_KEY ?? "";
-  if (key && !key.startsWith(KEY_PREFIX)) throw new Error(KEY_ERROR);
-  if (key && key.length !== KEY_LENGTH) throw new Error("UNRESTRICTED_API_KEY has the wrong length");
-  const home = homeOf(env, machine);
-  if (!home) throw new Error("HOME is not set and the home directory could not be found");
-  const { join: join4 } = pathsFor(machine.platform);
-  const model = env.UNRESTRICTED_MODEL || DEFAULT_MODEL;
-  const modelName = env.UNRESTRICTED_MODEL_NAME || DEFAULT_MODEL_NAME;
-  return {
-    key: key || null,
-    base: env.UNRESTRICTED_BASE_URL || DEFAULT_BASE_URL,
-    origin: stripTrailingSlashes(env.UNRESTRICTED_ORIGIN || env.UNRESTRICTED_SETUP_ORIGIN || DEFAULT_ORIGIN),
-    model,
-    modelName,
-    context: CONTEXT,
-    maxOutput: MAX_OUTPUT,
-    models: [{ id: model, name: modelName, context: CONTEXT, maxOutput: MAX_OUTPUT }],
-    provider: PROVIDER,
-    platform: machine.platform,
-    home,
-    configHome: env.XDG_CONFIG_HOME || join4(home, CONFIG_HOME_DIR),
-    piAgentDir: resolvePiAgentDir(env, home, machine.platform)
-  };
+function parseAccount(body) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const { balance_usd: balanceUsd, plan, month_spend_usd: monthSpendUsd, api_locked: apiLocked } = asObject(body);
+  const parsedPlan = parsePlan(plan);
+  if (!isAmount(balanceUsd) || !isAmount(monthSpendUsd) || typeof apiLocked !== "boolean" || parsedPlan === void 0) return null;
+  return { balanceUsd, plan: parsedPlan, monthSpendUsd, apiLocked };
+}
+async function fetchAccount(base, key) {
+  const url = `${base}/account`;
+  const answer = await getJson(url, { Authorization: `Bearer ${key}`, accept: "application/json" }, TIMEOUT_MS);
+  if (answer.status === 401) throw new Error('The key was rejected. Run "unrestricted login" to sign in again.');
+  if (answer.status === 403) throw new Error(errorMessage(answer.body) ?? `${url} refused the key.`);
+  if (!answer.ok) throw new Error(`${url} answered ${answer.status}.`);
+  const account = parseAccount(answer.body);
+  if (account === null) throw new Error(`Unexpected answer from ${url}.`);
+  return account;
 }
 
 // cli/src/format.ts
@@ -1081,68 +1337,17 @@ function table(rows, rightAligned = /* @__PURE__ */ new Set()) {
 }
 
 // cli/src/store.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { join } from "node:path";
-
-// cli/src/file-mode.ts
-import { chmodSync } from "node:fs";
-var WINDOWS = "win32";
-function setMode(path, mode, platform = process.platform) {
-  if (platform === WINDOWS) return;
-  chmodSync(path, mode);
-}
-
-// cli/src/paths.ts
-var CODEX_CONFIG_DIR = ".codex";
-var CODEX_CONFIG_FILE = "config.toml";
-var CLAUDE_CONFIG_DIR = ".claude";
-var CLAUDE_SETTINGS_FILE = "settings.json";
-var CLAUDE_SESSION_FILE = "claude-settings.json";
-var CLAUDE_LAUNCHER = "claude-unrestricted";
-var STORE_DIR_NAME = "unrestricted";
-var OPENCODE_PLUGINS_DIR = "plugins";
-var PI_EXTENSIONS_DIR = "extensions";
-var AUTO_UPDATE_FILE = "unrestricted.ts";
-function toolPaths(locations) {
-  const { join: join4 } = pathsFor(locations.platform);
-  const { home, configHome, piAgentDir } = locations;
-  const opencodeDir = join4(configHome, OPENCODE_CONFIG_DIR);
-  const crushDir = join4(configHome, CRUSH_CONFIG_DIR);
-  const continueDir = join4(home, CONTINUE_CONFIG_DIR);
-  const codexDir = join4(home, CODEX_CONFIG_DIR);
-  const claudeDir = join4(home, CLAUDE_CONFIG_DIR);
-  const claudeLauncherDir = join4(home, ".local", "bin");
-  return {
-    opencodeDir,
-    opencodeJson: join4(opencodeDir, OPENCODE_CONFIG_FILE),
-    opencodeJsonc: join4(opencodeDir, OPENCODE_JSONC_FILE),
-    opencodePlugin: join4(opencodeDir, OPENCODE_PLUGINS_DIR, AUTO_UPDATE_FILE),
-    crushDir,
-    crushrc: join4(crushDir, CRUSH_CONFIG_FILE),
-    piAgentDir,
-    piModels: join4(piAgentDir, PI_MODELS_FILE),
-    piSettings: join4(piAgentDir, PI_SETTINGS_FILE),
-    piExtension: join4(piAgentDir, PI_EXTENSIONS_DIR, AUTO_UPDATE_FILE),
-    continueDir,
-    continueConfig: join4(continueDir, CONTINUE_CONFIG_FILE),
-    aiderConfig: join4(home, AIDER_CONFIG_FILE),
-    codexDir,
-    codexConfig: join4(codexDir, CODEX_CONFIG_FILE),
-    claudeDir,
-    claudeGlobalSettings: join4(claudeDir, CLAUDE_SETTINGS_FILE),
-    claudeSessionSettings: join4(configHome, STORE_DIR_NAME, CLAUDE_SESSION_FILE),
-    claudeLauncherDir,
-    claudeLauncher: join4(claudeLauncherDir, CLAUDE_LAUNCHER)
-  };
-}
-
-// cli/src/store.ts
 var CREDENTIALS_FILE = "credentials.json";
 var STATE_FILE = "state.json";
-var DIR_MODE = 448;
-var FILE_MODE = 384;
+var DIR_MODE2 = 448;
+var FILE_MODE2 = 384;
 var WEB_ORIGIN = /^https?:\/\/\S+$/;
 var SHA256 = /^[0-9a-f]{64}$/;
+var MAX_DEFAULT_LENGTH = 512;
+var FIRST_PRINTABLE = " ";
+var DELETE = "\x7F";
 function storeDir(configHome) {
   return join(configHome, STORE_DIR_NAME);
 }
@@ -1158,7 +1363,7 @@ function isKey(value) {
 function readStoreFile(file) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(file, "utf8"));
+    parsed = JSON.parse(readFileSync3(file, "utf8"));
   } catch {
     return null;
   }
@@ -1166,12 +1371,12 @@ function readStoreFile(file) {
 }
 function writeStoreFile(configHome, file, value) {
   const dir = storeDir(configHome);
-  mkdirSync(dir, { recursive: true, mode: DIR_MODE });
-  setMode(dir, DIR_MODE);
+  mkdirSync2(dir, { recursive: true, mode: DIR_MODE2 });
+  setMode(dir, DIR_MODE2);
   const pending = `${file}.${process.pid}.tmp`;
-  writeFileSync2(pending, `${JSON.stringify(value, null, 2)}
-`, { mode: FILE_MODE });
-  setMode(pending, FILE_MODE);
+  writeFileSync3(pending, `${JSON.stringify(value, null, 2)}
+`, { mode: FILE_MODE2 });
+  setMode(pending, FILE_MODE2);
   renameSync(pending, file);
   return file;
 }
@@ -1190,8 +1395,8 @@ function saveCredentials(configHome, credentials) {
 }
 function deleteCredentials(configHome) {
   const file = credentialsPath(configHome);
-  if (!existsSync2(file)) return false;
-  rmSync(file, { force: true });
+  if (!existsSync(file)) return false;
+  rmSync3(file, { force: true });
   return true;
 }
 function readAutoUpdate(value) {
@@ -1206,16 +1411,54 @@ function readAutoUpdate(value) {
 function withAutoUpdate(value, records) {
   return records === void 0 || Object.keys(records).length === 0 ? value : { ...value, autoUpdate: records };
 }
+function isDefaultValue(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_DEFAULT_LENGTH && [...value].every((character) => character >= FIRST_PRINTABLE && character !== DELETE);
+}
+function readDefaults(value) {
+  const stored = asObject(value);
+  const defaults = {};
+  for (const tool of ALL_TOOLS) {
+    const recorded = stored[tool];
+    if (isDefaultValue(recorded)) defaults[tool] = recorded;
+  }
+  return defaults;
+}
+function withDefaults(value, defaults) {
+  return defaults === void 0 || Object.keys(defaults).length === 0 ? value : { ...value, defaults };
+}
 function readState(configHome) {
   const stored = readStoreFile(statePath(configHome));
   if (stored === null || !Array.isArray(stored.tools)) return null;
   const tools = unique(stored.tools.filter((tool) => typeof tool === "string" && isToolId(tool)));
   const models2 = Array.isArray(stored.models) ? unique(stored.models.filter(isModelId)) : [];
-  return withAutoUpdate({ tools, models: models2, model: isModelId(stored.model) ? stored.model : null }, readAutoUpdate(stored.autoUpdate));
+  const state = withAutoUpdate({ tools, models: models2, model: isModelId(stored.model) ? stored.model : null }, readAutoUpdate(stored.autoUpdate));
+  return withDefaults(state, readDefaults(stored.defaults));
 }
 function saveState(configHome, state) {
   const { tools, models: models2, model } = state;
-  return writeStoreFile(configHome, statePath(configHome), withAutoUpdate({ tools, models: models2, model }, state.autoUpdate));
+  const value = withDefaults(withAutoUpdate({ tools, models: models2, model }, state.autoUpdate), state.defaults);
+  return writeStoreFile(configHome, statePath(configHome), value);
+}
+function deleteState(configHome) {
+  const file = statePath(configHome);
+  if (!existsSync(file)) return false;
+  rmSync3(file, { force: true });
+  return true;
+}
+function forgetTools(configHome, state, forgotten) {
+  if (!state.tools.some((tool) => forgotten.includes(tool))) return;
+  const tools = state.tools.filter((tool) => !forgotten.includes(tool));
+  if (tools.length === 0) {
+    deleteState(configHome);
+    return;
+  }
+  const autoUpdate = { ...state.autoUpdate };
+  const defaults = { ...state.defaults };
+  for (const tool of forgotten) {
+    if (isAutoUpdateTool(tool)) delete autoUpdate[tool];
+    delete defaults[tool];
+  }
+  saveState(configHome, { ...state, tools, autoUpdate, defaults });
 }
 function mergeTools(previous, configured) {
   return unique([...previous, ...configured]);
@@ -1634,7 +1877,7 @@ async function models(context) {
 
 // cli/src/auto-update.ts
 import { createHash } from "node:crypto";
-import { lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname } from "node:path";
 
 // cli/src/templates/opencode-plugin.ts?raw
@@ -1647,29 +1890,25 @@ var pi_extension_default = 'type ListedModel = {\n  id: string;\n  name: string;
 import { spawnSync } from "node:child_process";
 
 // cli/src/detect.ts
-import { accessSync, constants, readdirSync, statSync } from "node:fs";
+import { accessSync, constants, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
-function isFile(path) {
+function isFile2(path) {
   try {
-    return statSync(path).isFile();
+    return statSync2(path).isFile();
   } catch {
     return false;
   }
 }
 function isDirectory(path) {
   try {
-    return statSync(path).isDirectory();
+    return statSync2(path).isDirectory();
   } catch {
     return false;
   }
 }
-function windowsVariable(env, name) {
-  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
-  return key === void 0 ? void 0 : env[key];
-}
 function isExecutable(path) {
-  if (!isFile(path)) return false;
+  if (!isFile2(path)) return false;
   try {
     accessSync(path, constants.X_OK);
     return true;
@@ -1680,11 +1919,11 @@ function isExecutable(path) {
 function hasWindowsCommand(dir, names) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return false;
   }
-  return entries.some((entry) => names.has(entry.toLowerCase()) && isFile(join2(dir, entry)));
+  return entries.some((entry) => names.has(entry.toLowerCase()) && isFile2(join2(dir, entry)));
 }
 function searchPath(value, platform) {
   const { delimiter } = pathsFor(platform);
@@ -1702,14 +1941,14 @@ function onPath(name, env = process.env, platform = process.platform) {
 function windowsCommandIn(dir, name, extensions) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return null;
   }
   for (const extension of extensions) {
     const wanted = `${name}${extension}`.toLowerCase();
     const entry = entries.find((candidate) => candidate.toLowerCase() === wanted);
-    if (entry !== void 0 && isFile(join2(dir, entry))) return join2(dir, entry);
+    if (entry !== void 0 && isFile2(join2(dir, entry))) return join2(dir, entry);
   }
   return null;
 }
@@ -1733,8 +1972,14 @@ function detect(tool, config, env = process.env) {
       return found("opencode") || isDirectory(paths.opencodeDir);
     case "codex":
       return found("codex") || isDirectory(paths.codexDir);
+    case "qwen-code":
+      return found("qwen") || isDirectory(paths.qwenDir);
+    case "goose":
+      return found("goose") || isDirectory(paths.gooseDir);
+    case "openhands":
+      return found("openhands") || isDirectory(paths.openhandsDir);
     case "aider":
-      return found("aider") || isFile(paths.aiderConfig);
+      return found("aider") || isFile2(paths.aiderConfig);
     case "continue":
       return isDirectory(paths.continueDir);
     case "crush":
@@ -1826,7 +2071,7 @@ function sha256(text) {
 function isOwnFile(text, marker) {
   return text.split(/\r?\n/).some((line) => line.trim() === marker);
 }
-function isMissing(error) {
+function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function readExisting(path, marker) {
@@ -1834,21 +2079,21 @@ function readExisting(path, marker) {
   try {
     stats = lstatSync(path);
   } catch (error) {
-    if (isMissing(error)) return { kind: "missing" };
+    if (isMissing2(error)) return { kind: "missing" };
     throw error;
   }
   if (!stats.isFile()) return { kind: "foreign" };
-  const text = readFileSync3(path, "utf8");
+  const text = readFileSync4(path, "utf8");
   return isOwnFile(text, marker) ? { kind: "ours", text } : { kind: "foreign" };
 }
 function writeAtomically(path, text) {
-  mkdirSync2(dirname(path), { recursive: true });
+  mkdirSync3(dirname(path), { recursive: true });
   const pending = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync3(pending, text);
+    writeFileSync4(pending, text);
     renameSync2(pending, path);
   } finally {
-    rmSync2(pending, { force: true });
+    rmSync4(pending, { force: true });
   }
 }
 function writeAutoUpdateFile(tool, config, version2) {
@@ -1858,7 +2103,7 @@ function writeAutoUpdateFile(tool, config, version2) {
   const existing = readExisting(path, file.marker);
   if (!isAtLeast(version2, file.minimum)) {
     if (existing.kind !== "ours") return { status: "unsupported" };
-    rmSync2(path, { force: true });
+    rmSync4(path, { force: true });
     return { status: "removed", path };
   }
   if (existing.kind === "foreign") return { status: "foreign", path };
@@ -1867,6 +2112,17 @@ function writeAutoUpdateFile(tool, config, version2) {
   writeAtomically(path, file.source);
   return { status: "written", path, sha256: hash };
 }
+function hasOwnAutoUpdateFile(tool, locations) {
+  const file = AUTO_UPDATE_FILES[tool];
+  return readExisting(file.path(toolPaths(locations)), file.marker).kind === "ours";
+}
+function removeAutoUpdateFile(tool, locations) {
+  const file = AUTO_UPDATE_FILES[tool];
+  const path = file.path(toolPaths(locations));
+  if (readExisting(path, file.marker).kind !== "ours") return null;
+  rmSync4(path, { force: true });
+  return path;
+}
 function installAutoUpdate(tool, config, versionOf) {
   const file = AUTO_UPDATE_FILES[tool];
   try {
@@ -1900,27 +2156,116 @@ function autoUpdateMessage(tool, result) {
 }
 
 // cli/src/writers/aider.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-function write(config) {
+var aider_exports = {};
+__export(aider_exports, {
+  currentDefault: () => currentDefault,
+  hasOwnEntries: () => hasOwnEntries,
+  remove: () => remove,
+  write: () => write
+});
+var TOOL = "aider";
+var SETTING = /^(openai-api-base|openai-api-key|model):\s*(.*?)\s*$/;
+var MODEL_PREFIX = "openai/";
+function setting(line) {
+  const match = SETTING.exec(line);
+  return match === null ? null : { key: match[1], value: match[2] };
+}
+function isModelLine(line) {
+  return setting(line)?.key === "model";
+}
+function isOwnLine(line, owner) {
+  const found = setting(line);
+  if (found === null) return false;
+  switch (found.key) {
+    case "openai-api-base":
+      return found.value === owner.base;
+    case "openai-api-key":
+      return found.value.startsWith(KEY_PREFIX);
+    default:
+      return found.value.startsWith(MODEL_PREFIX) && isOwnModel(found.value.slice(MODEL_PREFIX.length), owner);
+  }
+}
+function write(config, options) {
   const file = toolPaths(config).aiderConfig;
-  if (!existsSync3(file)) writeFileSync4(file, "");
-  const raw = readFileSync4(file, "utf8");
-  const content = toLf(raw);
-  const existing = content === "" ? [] : (content.endsWith("\n") ? content.slice(0, -1) : content).split("\n");
-  const kept = existing.filter((line) => !/^(openai-api-base|openai-api-key|model):/.test(line));
-  kept.push(`openai-api-base: ${config.base}`, `openai-api-key: ${config.key}`, `model: openai/${config.model}`);
-  writeFileSync4(file, fromLf(`${kept.join("\n")}
-`, layoutOf(raw)));
+  const raw = readText(file);
+  const replaced = (line) => {
+    const key = setting(line)?.key;
+    return key !== void 0 && (key !== "model" || options.setDefault);
+  };
+  const kept = splitLines(toLf(raw ?? "")).filter((line) => !replaced(line));
+  kept.push(`openai-api-base: ${config.base}`, `openai-api-key: ${config.key}`);
+  if (options.setDefault) kept.push(`model: ${MODEL_PREFIX}${config.model}`);
+  saveText(config, TOOL, file, fromLf(`${kept.join("\n")}
+`, layoutOf(raw ?? "")), raw);
   setMode(file, 384, config.platform);
   return { path: file, next: "aider" };
 }
+function currentDefault(config) {
+  let raw;
+  try {
+    raw = readText(toolPaths(config).aiderConfig);
+  } catch {
+    return null;
+  }
+  const models2 = splitLines(toLf(raw ?? "")).map(setting).filter((found) => found !== null && found.key === "model" && found.value !== "");
+  return models2.at(-1)?.value ?? null;
+}
+function removal(config, previousDefault) {
+  const file = toolPaths(config).aiderConfig;
+  const raw = readText(file);
+  if (raw === null) return [];
+  const lines = splitLines(toLf(raw));
+  const own = (line) => isOwnLine(line, config);
+  if (!lines.some(own)) return [];
+  const kept = lines.filter((line) => !own(line));
+  const lastModel = lines.findLastIndex(isModelLine);
+  if (previousDefault !== null && lastModel !== -1 && own(lines[lastModel]) && !kept.some(isModelLine)) {
+    kept.splice(lines.slice(0, lastModel).filter((line) => !own(line)).length, 0, `model: ${previousDefault}`);
+  }
+  return [{ file, raw, next: kept.every(isBlankText) ? null : fromLf(`${kept.join("\n")}
+`, layoutOf(raw)) }];
+}
+function remove(config, previousDefault) {
+  const changes = removal(config, previousDefault);
+  applyChanges(config, TOOL, changes);
+  return { path: toolPaths(config).aiderConfig, changed: changes.length > 0 };
+}
+function hasOwnEntries(config) {
+  return removal(config, null).length > 0;
+}
 
 // cli/src/writers/claude.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "node:fs";
+var claude_exports = {};
+__export(claude_exports, {
+  apiOrigin: () => apiOrigin,
+  currentDefault: () => currentDefault2,
+  hasOwnEntries: () => hasOwnEntries2,
+  launcherPath: () => launcherPath,
+  remove: () => remove2,
+  settingsPath: () => settingsPath,
+  write: () => write2
+});
+import { mkdirSync as mkdirSync4, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname2, resolve } from "node:path";
+var TOOL2 = "claude";
+var SESSION_ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+  "CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT"
+];
+var MODEL_PICKER = "modelPicker";
 function apiOrigin(base) {
   return base.replace(/\/v1$/, "");
 }
+function settingsPath(config) {
+  return toolPaths(config).claudeSessionSettings;
+}
+function launcherPath(config) {
+  return toolPaths(config).claudeLauncher;
+}
 function underHome(path, home) {
   return path.startsWith(`${home}/`) ? path.slice(home.length + 1) : "";
 }
@@ -1932,50 +2277,61 @@ function shellPath(path, home) {
   const rest = underHome(path, home);
   return rest ? `"$HOME/${rest}"` : `"${path}"`;
 }
+function launcherText(settings, home) {
+  return `#!/bin/sh
+exec claude --settings ${shellPath(settings, home)} "$@"
+`;
+}
 function pathContains(dir, env, platform) {
   return (env.PATH ?? "").split(pathsFor(platform).delimiter).filter(Boolean).some((entry) => resolve(entry) === resolve(dir));
 }
-function isOurs(name, value, config) {
+function isOurs(name, value, owner) {
   if (typeof value !== "string") return false;
   switch (name) {
     case "ANTHROPIC_BASE_URL":
-      return value === apiOrigin(config.base);
+      return value === apiOrigin(owner.base);
     case "ANTHROPIC_AUTH_TOKEN":
       return value.startsWith(KEY_PREFIX);
     case "ANTHROPIC_MODEL":
     case "ANTHROPIC_SMALL_FAST_MODEL":
-      return isOwnModel(value, config);
+      return isOwnModel(value, owner);
     default:
       return false;
   }
 }
-function removeGlobalEnv(config) {
-  const file = toolPaths(config).claudeGlobalSettings;
-  if (!existsSync4(file)) return void 0;
-  let document;
-  try {
-    document = readJsonDocument(file);
-  } catch {
-    return void 0;
-  }
-  const settings = document.value;
+function withoutOwnGlobalEnv(settings, owner) {
   const env = asObject(settings.env);
   const kept = {};
   let removed = 0;
   for (const [name, value] of Object.entries(env)) {
-    if (isOurs(name, value, config)) removed += 1;
+    if (isOurs(name, value, owner)) removed += 1;
     else kept[name] = value;
   }
-  if (removed === 0) return void 0;
-  if (Object.keys(kept).length > 0) settings.env = kept;
-  else delete settings.env;
-  writeJsonDocument(file, settings, document.layout);
+  if (removed === 0) return null;
+  const next = { ...settings, env: kept };
+  if (Object.keys(kept).length === 0) delete next.env;
+  return next;
+}
+function readGlobalSettings(file) {
+  try {
+    const document = readJsonDocument(file);
+    return document.raw === null ? null : document;
+  } catch {
+    return null;
+  }
+}
+function removeGlobalEnv(config) {
+  const file = toolPaths(config).claudeGlobalSettings;
+  const document = readGlobalSettings(file);
+  const next = document === null ? null : withoutOwnGlobalEnv(document.value, config);
+  if (document === null || next === null) return void 0;
+  saveText(config, TOOL2, file, jsonText(next, document.layout), document.raw);
   return `Removed the old global unrestricted.sh env from ${displayPath(file, config.home)}`;
 }
-function write2(config, env = process.env) {
+function write2(config, _options, env = process.env) {
   const paths = toolPaths(config);
   const file = paths.claudeSessionSettings;
-  mkdirSync3(dirname2(file), { recursive: true });
+  mkdirSync4(dirname2(file), { recursive: true });
   const document = readJsonDocument(file);
   const settings = document.value;
   settings.env = {
@@ -1987,63 +2343,129 @@ function write2(config, env = process.env) {
     CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(config.context),
     CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT: "1"
   };
-  settings.modelPicker = {
+  settings[MODEL_PICKER] = {
     options: [{ model: config.model, label: config.modelName, description: "unrestricted.sh" }],
     replaceBuiltInOptions: true
   };
-  writeJsonDocument(file, settings, document.layout);
+  saveText(config, TOOL2, file, jsonText(settings, document.layout), document.raw);
   setMode(file, 384, config.platform);
   const launcher = paths.claudeLauncher;
   const bin = paths.claudeLauncherDir;
-  mkdirSync3(bin, { recursive: true });
-  writeFileSync5(launcher, `#!/bin/sh
-exec claude --settings ${shellPath(file, config.home)} "$@"
-`);
+  mkdirSync4(bin, { recursive: true });
+  writeFileSync5(launcher, launcherText(file, config.home));
   setMode(launcher, 493, config.platform);
   const hint = removeGlobalEnv(config);
   const next = pathContains(bin, env, config.platform) ? CLAUDE_LAUNCHER : `claude --settings ${displayPath(file, config.home)} (or add ~/.local/bin to PATH for ${CLAUDE_LAUNCHER})`;
   return hint ? { path: file, next, hint } : { path: file, next };
 }
+function currentDefault2(_config) {
+  return null;
+}
+function withoutOwnSessionSettings(settings) {
+  const env = asObject(settings.env);
+  const keptEnv = Object.fromEntries(Object.entries(env).filter(([name]) => !SESSION_ENV_KEYS.includes(name)));
+  const ownEnv = Object.keys(keptEnv).length < Object.keys(env).length;
+  if (!ownEnv && !(MODEL_PICKER in settings)) return null;
+  const next = { ...settings, env: keptEnv };
+  if (Object.keys(keptEnv).length === 0) delete next.env;
+  delete next[MODEL_PICKER];
+  return next;
+}
+function changeTo(file, document, value) {
+  return { file, raw: document.raw, next: isBareDocument(value) ? null : jsonText(value, document.layout) };
+}
+function removal2(config) {
+  const paths = toolPaths(config);
+  const changes = [];
+  const session = readJsonDocument(paths.claudeSessionSettings);
+  const cleaned = session.raw === null ? null : withoutOwnSessionSettings(session.value);
+  if (cleaned !== null) changes.push(changeTo(paths.claudeSessionSettings, session, cleaned));
+  const global = readGlobalSettings(paths.claudeGlobalSettings);
+  const globalCleaned = global === null ? null : withoutOwnGlobalEnv(global.value, config);
+  if (global !== null && globalCleaned !== null) changes.push(changeTo(paths.claudeGlobalSettings, global, globalCleaned));
+  const launcher = readText(paths.claudeLauncher);
+  const ownLauncher = launcher !== null && launcher === launcherText(paths.claudeSessionSettings, config.home);
+  return { changes, launcher: ownLauncher ? paths.claudeLauncher : null };
+}
+function remove2(config, _previousDefault) {
+  const plan = removal2(config);
+  applyChanges(config, TOOL2, plan.changes);
+  if (plan.launcher !== null) rmSync5(plan.launcher, { force: true });
+  return {
+    path: plan.changes[0]?.file ?? plan.launcher ?? toolPaths(config).claudeSessionSettings,
+    changed: plan.changes.length > 0 || plan.launcher !== null
+  };
+}
+function hasOwnEntries2(config) {
+  const plan = removal2(config);
+  return plan.changes.length > 0 || plan.launcher !== null;
+}
 
 // cli/src/writers/codex.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "node:fs";
+var codex_exports = {};
+__export(codex_exports, {
+  applyTopLevelKeys: () => applyTopLevelKeys,
+  currentDefault: () => currentDefault3,
+  hasOwnEntries: () => hasOwnEntries3,
+  remove: () => remove3,
+  startCommand: () => startCommand,
+  write: () => write3
+});
+import { mkdirSync as mkdirSync5, rmSync as rmSync6 } from "node:fs";
 
 // cli/src/env-file.ts
-import { appendFileSync, mkdirSync as mkdirSync4, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join3 } from "node:path";
-function isFile2(path) {
-  try {
-    return statSync2(path).isFile();
-  } catch {
-    return false;
-  }
+var ENV_FILE = "env";
+var KEY_EXPORT = new RegExp(`^export ${API_KEY_ENV}=unr_sk_\\S*$`);
+function envFilePath(config) {
+  return join3(config.configHome, STORE_DIR_NAME, ENV_FILE);
 }
-function writeEnvFile(config) {
-  const dir = join3(config.configHome, "unrestricted");
-  const file = join3(dir, "env");
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync6(file, `export UNRESTRICTED_API_KEY=${config.key}
-`);
-  setMode(file, 384, config.platform);
-  for (const rc of [join3(config.home, ".zshrc"), join3(config.home, ".bashrc")]) {
-    if (!isFile2(rc)) continue;
-    const content = readFileSync5(rc, "utf8");
-    if (content.includes(file)) continue;
-    appendFileSync(rc, fromLf(`
-. "${file}"
-`, { eol: layoutOf(content).eol, bom: false }));
+function shellProfiles(config) {
+  return [join3(config.home, ".zshrc"), join3(config.home, ".bashrc")];
+}
+function sourceLine(file) {
+  return `. "${file}"`;
+}
+function isOwnEnvFile(text) {
+  const lines = splitLines(toLf(text)).filter((line) => !isBlankText(line));
+  return lines.length > 0 && lines.every((line) => KEY_EXPORT.test(line));
+}
+function withoutSourceLine(lines, source) {
+  const kept = [];
+  for (const line of lines) {
+    if (line !== source) kept.push(line);
+    else if (kept.length > 0 && kept[kept.length - 1] === "") kept.pop();
   }
-  return file;
+  return kept;
+}
+function envFileRemoval(config) {
+  const file = envFilePath(config);
+  const text = readText(file);
+  if (text === null || !isOwnEnvFile(text)) return { envFile: null, changes: [] };
+  const changes = [];
+  for (const rc of shellProfiles(config)) {
+    const raw = isFile(rc) ? readText(rc) : null;
+    if (raw === null) continue;
+    const lines = splitLines(toLf(raw));
+    const kept = withoutSourceLine(lines, sourceLine(file));
+    if (kept.length === lines.length) continue;
+    changes.push({ file: rc, raw, next: fromLf(kept.length === 0 ? "" : `${kept.join("\n")}
+`, layoutOf(raw)) });
+  }
+  return { envFile: file, changes };
 }
 
 // cli/src/writers/codex.ts
-function splitLines(content) {
-  if (content === "") return [];
-  return (content.endsWith("\n") ? content.slice(0, -1) : content).split("\n");
-}
+var TOOL3 = "codex";
+var WIRE_API = "responses";
+var PROVIDER_KEY = /^model_provider[ \t]*=/;
+var MODEL_KEY = /^model[ \t]*=/;
+var STRING_VALUE = /^[A-Za-z_]+[ \t]*=[ \t]*"([^"]*)"/;
+var PROVIDER_SEPARATOR = "/";
+var LEGACY_ENV_KEY_LINE = `env_key = "${API_KEY_ENV}"`;
 function applyTopLevelKeys(content, provider, model) {
   const providerLine = `model_provider = "${provider}"`;
-  const modelLine2 = `model = "${model}"`;
+  const modelLine3 = `model = "${model}"`;
   const lines = [];
   let inTable = false;
   let seenProvider = false;
@@ -2052,7 +2474,7 @@ function applyTopLevelKeys(content, provider, model) {
     if (line.startsWith("[")) {
       if (!inTable) {
         if (!seenProvider) lines.push(providerLine);
-        if (!seenModel) lines.push(modelLine2);
+        if (!seenModel) lines.push(modelLine3);
         seenProvider = true;
         seenModel = true;
       }
@@ -2060,49 +2482,167 @@ function applyTopLevelKeys(content, provider, model) {
       lines.push(line);
       continue;
     }
-    if (!inTable && /^model_provider[ \t]*=/.test(line)) {
+    if (!inTable && PROVIDER_KEY.test(line)) {
       lines.push(providerLine);
       seenProvider = true;
       continue;
     }
-    if (!inTable && /^model[ \t]*=/.test(line)) {
-      lines.push(modelLine2);
+    if (!inTable && MODEL_KEY.test(line)) {
+      lines.push(modelLine3);
       seenModel = true;
       continue;
     }
     lines.push(line);
   }
   if (!seenProvider) lines.push(providerLine);
-  if (!seenModel) lines.push(modelLine2);
+  if (!seenModel) lines.push(modelLine3);
   return `${lines.join("\n")}
 `;
 }
-function write3(config) {
-  const { codexDir: dir, codexConfig: file } = toolPaths(config);
-  mkdirSync5(dir, { recursive: true });
-  if (!existsSync5(file)) writeFileSync7(file, "");
-  const raw = readFileSync6(file, "utf8");
-  let content = toLf(raw);
-  const header = new RegExp(`^\\[model_providers\\.${config.provider}\\]`, "m");
-  if (!header.test(content)) {
-    content += `
-[model_providers.${config.provider}]
-name = "unrestricted.sh"
-base_url = "${config.base}"
-env_key = "UNRESTRICTED_API_KEY"
-wire_api = "responses"
+function tableHeader(provider) {
+  return `[model_providers.${provider}]`;
+}
+function tableKeys(config) {
+  return [
+    { name: "name", value: PROVIDER_NAME },
+    { name: "base_url", value: config.base },
+    { name: "experimental_bearer_token", value: config.key },
+    { name: "wire_api", value: WIRE_API }
+  ];
+}
+function keyLine(key) {
+  return `${key.name} = "${key.value}"`;
+}
+function keyPattern(name) {
+  return new RegExp(`^${name}[ \\t]*=`);
+}
+function tableEnd(lines, start2) {
+  const next = lines.findIndex((line, index) => index > start2 && line.startsWith("["));
+  return next === -1 ? lines.length : next;
+}
+function withOwnTable(content, config) {
+  const lines = splitLines(content);
+  const header = tableHeader(config.provider);
+  const start2 = lines.findIndex((line) => line.trim() === header);
+  if (start2 === -1) return `${content}
+${[header, ...tableKeys(config).map(keyLine)].join("\n")}
 `;
+  const end = tableEnd(lines, start2);
+  const body = lines.slice(start2 + 1, end).filter((line) => line.trim() !== LEGACY_ENV_KEY_LINE);
+  for (const key of tableKeys(config)) {
+    const at = body.findIndex((line) => keyPattern(key.name).test(line));
+    if (at !== -1) {
+      body[at] = keyLine(key);
+      continue;
+    }
+    const lastContent = body.findLastIndex((line) => !isBlankText(line));
+    body.splice(lastContent + 1, 0, keyLine(key));
   }
-  writeFileSync7(file, fromLf(applyTopLevelKeys(content, config.provider, config.model), layoutOf(raw)));
+  return `${[...lines.slice(0, start2 + 1), ...body, ...lines.slice(end)].join("\n")}
+`;
+}
+function topLevelEnd(lines) {
+  const firstTable = lines.findIndex((line) => line.startsWith("["));
+  return firstTable === -1 ? lines.length : firstTable;
+}
+function stringValue(line) {
+  const match = line === void 0 ? null : STRING_VALUE.exec(line);
+  return match === null ? null : match[1];
+}
+function defaultIn(content) {
+  const lines = splitLines(content);
+  const top = lines.slice(0, topLevelEnd(lines));
+  const model = stringValue(top.find((line) => MODEL_KEY.test(line)));
+  if (model === null || model === "") return null;
+  const provider = stringValue(top.find((line) => PROVIDER_KEY.test(line)));
+  return provider === null || provider === "" ? model : `${provider}${PROVIDER_SEPARATOR}${model}`;
+}
+function startCommand(config) {
+  return `codex -c model_provider=${config.provider} -m ${config.model}`;
+}
+function write3(config, options) {
+  const { codexDir: dir, codexConfig: file } = toolPaths(config);
+  mkdirSync5(dir, { recursive: true });
+  const raw = readText(file);
+  const content = withOwnTable(toLf(raw ?? ""), config);
+  const updated = options.setDefault ? applyTopLevelKeys(content, config.provider, config.model) : content;
+  saveText(config, TOOL3, file, fromLf(updated, layoutOf(raw ?? "")), raw);
   setMode(file, 384, config.platform);
-  const envFile = writeEnvFile(config);
-  return { path: file, next: `open a new shell (or: . ${envFile}) then codex` };
+  const startsOnOwnModel = defaultIn(updated)?.startsWith(`${config.provider}${PROVIDER_SEPARATOR}`) ?? false;
+  return { path: file, next: startsOnOwnModel ? "codex" : startCommand(config) };
+}
+function currentDefault3(config) {
+  let raw;
+  try {
+    raw = readText(toolPaths(config).codexConfig);
+  } catch {
+    return null;
+  }
+  return defaultIn(toLf(raw ?? ""));
+}
+function restoredLines(previousDefault) {
+  const slash = previousDefault.indexOf(PROVIDER_SEPARATOR);
+  if (slash <= 0) return [`model = "${previousDefault}"`];
+  return [`model_provider = "${previousDefault.slice(0, slash)}"`, `model = "${previousDefault.slice(slash + 1)}"`];
+}
+function withoutOwnSettings(raw, owner, previousDefault) {
+  const lines = splitLines(toLf(raw));
+  const end = topLevelEnd(lines);
+  const providerAt = lines.findIndex((line, index) => index < end && PROVIDER_KEY.test(line));
+  const modelAt = lines.findIndex((line, index) => index < end && MODEL_KEY.test(line));
+  const model = stringValue(lines[modelAt]);
+  const ownProvider2 = providerAt !== -1 && stringValue(lines[providerAt]) === owner.provider;
+  const ownDefault = ownProvider2 && model !== null && isOwnModel(model, owner);
+  const dropped = /* @__PURE__ */ new Set();
+  if (ownProvider2) dropped.add(providerAt);
+  if (ownDefault) dropped.add(modelAt);
+  const tableAt = lines.findIndex((line) => line.trim() === tableHeader(owner.provider));
+  if (tableAt !== -1) {
+    if (tableAt > 0 && isBlankText(lines[tableAt - 1])) dropped.add(tableAt - 1);
+    for (let index = tableAt; index < tableEnd(lines, tableAt); index += 1) dropped.add(index);
+  }
+  if (dropped.size === 0) return void 0;
+  const kept = lines.filter((_line, index) => !dropped.has(index));
+  if (ownDefault && previousDefault !== null) {
+    const firstOwn = Math.min(...[providerAt, modelAt].filter((index) => index !== -1));
+    kept.splice(lines.slice(0, firstOwn).filter((_line, index) => !dropped.has(index)).length, 0, ...restoredLines(previousDefault));
+  }
+  return kept.every(isBlankText) ? null : fromLf(`${kept.join("\n")}
+`, layoutOf(raw));
+}
+function removal3(config, previousDefault) {
+  const file = toolPaths(config).codexConfig;
+  const raw = readText(file);
+  const next = raw === null ? void 0 : withoutOwnSettings(raw, config, previousDefault);
+  const env = envFileRemoval(config);
+  const changes = next === void 0 ? [] : [{ file, raw, next }];
+  return { changes: [...changes, ...env.changes], envFile: env.envFile };
+}
+function remove3(config, previousDefault) {
+  const plan = removal3(config, previousDefault);
+  applyChanges(config, TOOL3, plan.changes);
+  if (plan.envFile !== null) rmSync6(plan.envFile, { force: true });
+  const file = toolPaths(config).codexConfig;
+  return { path: plan.changes[0]?.file ?? plan.envFile ?? file, changed: plan.changes.length > 0 || plan.envFile !== null };
+}
+function hasOwnEntries3(config) {
+  const plan = removal3(config, null);
+  return plan.changes.length > 0 || plan.envFile !== null;
 }
 
 // cli/src/writers/continue.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "node:fs";
+var continue_exports = {};
+__export(continue_exports, {
+  currentDefault: () => currentDefault4,
+  hasOwnEntries: () => hasOwnEntries4,
+  remove: () => remove4,
+  write: () => write4
+});
+import { mkdirSync as mkdirSync6 } from "node:fs";
+var TOOL4 = "continue";
 var ITEM_START = "  - ";
 var ITEM_FIELD = /^ {4}([A-Za-z]+):\s*(.*?)\s*$/;
+var CREATED_HEADER = ["name: unrestricted.sh", "version: 0.0.1", "schema: v1", "models:"];
 function modelEntry(config, model) {
   return [
     `  - name: unrestricted.sh ${model.name}`,
@@ -2123,10 +2663,6 @@ function lastTopLevelLine(content) {
   const lines = content.split("\n").filter((line) => /^[A-Za-z]/.test(line));
   return lines.length ? lines[lines.length - 1] : "";
 }
-function splitLines2(content) {
-  if (content === "") return [];
-  return (content.endsWith("\n") ? content.slice(0, -1) : content).split("\n");
-}
 function modelItems(lines) {
   const header = lines.findIndex((line) => /^models:\s*$/.test(line));
   if (header === -1) return [];
@@ -2147,12 +2683,12 @@ function itemField(lines, item, field) {
   }
   return void 0;
 }
-function isOwnItem(lines, item, config) {
+function isOwnItem(lines, item, owner) {
   const model = itemField(lines, item, "model");
-  return model !== void 0 && isOwnModel(model, config) && itemField(lines, item, "apiBase") === config.base;
+  return model !== void 0 && isOwnModel(model, owner) && itemField(lines, item, "apiBase") === owner.base;
 }
 function replaceOwnItems(content, entries, config) {
-  const lines = splitLines2(content);
+  const lines = splitLines(content);
   const own = modelItems(lines).filter((item) => isOwnItem(lines, item, config));
   if (own.length === 0) return null;
   const updated = [];
@@ -2166,81 +2702,460 @@ function replaceOwnItems(content, entries, config) {
   return `${updated.join("\n")}
 `;
 }
-function write4(config) {
+function write4(config, _options) {
   const { continueDir: dir, continueConfig: file } = toolPaths(config);
   mkdirSync6(dir, { recursive: true });
   const entries = modelEntries(config);
   const next = `reload Continue and pick "unrestricted.sh ${config.modelName}"`;
-  if (!existsSync6(file)) {
-    writeFileSync8(file, `name: unrestricted.sh
-version: 0.0.1
-schema: v1
-models:
+  const raw = readText(file);
+  if (raw === null) {
+    saveText(config, TOOL4, file, `${CREATED_HEADER.join("\n")}
 ${entries}
-`);
+`, null);
     setMode(file, 384, config.platform);
     return { path: file, next };
   }
-  const raw = readFileSync7(file, "utf8");
   const layout = layoutOf(raw);
   const content = toLf(raw);
   const replaced = replaceOwnItems(content, entries, config);
   if (replaced !== null) {
-    if (replaced !== content) writeFileSync8(file, fromLf(replaced, layout));
+    if (replaced !== content) saveText(config, TOOL4, file, fromLf(replaced, layout), raw);
     return { path: file, next };
   }
   if (content.includes(`apiBase: ${config.base}`)) return { path: file, next };
   if (lastTopLevelLine(content) === "models:") {
-    writeFileSync8(file, fromLf(`${content}${entries}
-`, layout));
+    saveText(config, TOOL4, file, fromLf(`${content}${entries}
+`, layout), raw);
     return { path: file, next };
   }
   return { path: file, next, hint: `could not merge into ${file} automatically; add this under models:
 ${entries}` };
 }
+function currentDefault4(_config) {
+  return null;
+}
+function isCreatedHeader(lines) {
+  return lines.length === CREATED_HEADER.length && lines.every((line, index) => line === CREATED_HEADER[index]);
+}
+function removal4(config) {
+  const file = toolPaths(config).continueConfig;
+  const raw = readText(file);
+  if (raw === null) return [];
+  const lines = splitLines(toLf(raw));
+  const own = modelItems(lines).filter((item) => isOwnItem(lines, item, config));
+  if (own.length === 0) return [];
+  const kept = lines.filter((_line, index) => !own.some((item) => index >= item.start && index < item.end));
+  const next = isCreatedHeader(kept) || kept.every(isBlankText) ? null : fromLf(`${kept.join("\n")}
+`, layoutOf(raw));
+  return [{ file, raw, next }];
+}
+function remove4(config, _previousDefault) {
+  const changes = removal4(config);
+  applyChanges(config, TOOL4, changes);
+  return { path: toolPaths(config).continueConfig, changed: changes.length > 0 };
+}
+function hasOwnEntries4(config) {
+  return removal4(config).length > 0;
+}
 
 // cli/src/writers/crush.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "node:fs";
-function splitLines3(content) {
-  if (content === "") return [];
-  return (content.endsWith("\n") ? content.slice(0, -1) : content).split("\n");
-}
-function isOwnLine(line, config) {
-  const [command, action, target = ""] = line.trim().split(/\s+/);
-  if (command === "provider" && action === "add") return target === config.provider;
+var crush_exports = {};
+__export(crush_exports, {
+  currentDefault: () => currentDefault5,
+  hasOwnEntries: () => hasOwnEntries5,
+  remove: () => remove5,
+  write: () => write5
+});
+import { mkdirSync as mkdirSync7 } from "node:fs";
+var TOOL5 = "crush";
+function words(line) {
+  return line.trim().split(/\s+/);
+}
+function isUseLine(line) {
+  const [command, action] = words(line);
+  return command === "model" && action === "use";
+}
+function useTarget(line) {
+  const [command, action, target = ""] = words(line);
+  return command === "model" && action === "use" && target !== "" ? target : null;
+}
+function isOwnLine2(line, owner) {
+  const [command, action, target = ""] = words(line);
+  if (command === "provider" && action === "add") return target === owner.provider;
   if (command !== "model" || action !== "add" && action !== "use") return false;
-  const prefix = `${config.provider}/`;
-  return target.startsWith(prefix) && isOwnModel(target.slice(prefix.length), config);
+  const prefix = `${owner.provider}/`;
+  return target.startsWith(prefix) && isOwnModel(target.slice(prefix.length), owner);
 }
 function modelLine(config, model) {
   return `model add ${config.provider}/${model.id} --name "${model.name}" --context-window ${model.context} --default-max-tokens ${model.maxOutput} --can-reason true`;
 }
-function ownLines(config) {
+function ownBlock(config) {
   return [
     `provider add ${config.provider} --type openai-compat --base-url "${config.base}" --api-key "${config.key}"`,
-    ...config.models.map((model) => modelLine(config, model)),
-    `model use ${config.provider}/${config.model}`
+    ...config.models.map((model) => modelLine(config, model))
   ];
 }
-function write5(config) {
+function write5(config, options) {
   const { crushDir: dir, crushrc: file } = toolPaths(config);
   mkdirSync7(dir, { recursive: true });
-  const raw = existsSync7(file) ? readFileSync8(file, "utf8") : "";
-  const lines = splitLines3(toLf(raw));
-  const firstOwn = lines.findIndex((line) => isOwnLine(line, config));
-  const kept = lines.filter((line) => !isOwnLine(line, config));
-  kept.splice(firstOwn === -1 ? kept.length : firstOwn, 0, ...ownLines(config));
-  const updated = fromLf(`${kept.join("\n")}
-`, layoutOf(raw));
-  if (updated !== raw) {
-    writeFileSync9(file, updated);
-    setMode(file, 384, config.platform);
+  const raw = readText(file);
+  const lines = splitLines(toLf(raw ?? ""));
+  const replaced = (line) => isOwnLine2(line, config) && (options.setDefault || !isUseLine(line));
+  const firstOwn = lines.findIndex((line) => isOwnLine2(line, config));
+  const kept = lines.filter((line) => !replaced(line));
+  const at = firstOwn === -1 ? kept.length : firstOwn;
+  const block = ownBlock(config);
+  kept.splice(at, 0, ...block);
+  if (options.setDefault) {
+    const end = at + block.length;
+    kept.splice(kept.slice(end).some(isUseLine) ? kept.length : end, 0, `model use ${config.provider}/${config.model}`);
   }
+  const updated = fromLf(`${kept.join("\n")}
+`, layoutOf(raw ?? ""));
+  if (saveText(config, TOOL5, file, updated, raw)) setMode(file, 384, config.platform);
   return { path: file, next: "crush" };
 }
+function currentDefault5(config) {
+  let raw;
+  try {
+    raw = readText(toolPaths(config).crushrc);
+  } catch {
+    return null;
+  }
+  if (raw === null) return null;
+  const targets = splitLines(toLf(raw)).map(useTarget).filter((target) => target !== null);
+  return targets.at(-1) ?? null;
+}
+function removal5(config, previousDefault) {
+  const file = toolPaths(config).crushrc;
+  const raw = readText(file);
+  if (raw === null) return [];
+  const lines = splitLines(toLf(raw));
+  const own = (line) => isOwnLine2(line, config);
+  if (!lines.some(own)) return [];
+  const kept = lines.filter((line) => !own(line));
+  const lastUse = lines.findLastIndex(isUseLine);
+  if (previousDefault !== null && lastUse !== -1 && own(lines[lastUse]) && !kept.some(isUseLine)) {
+    kept.splice(lines.slice(0, lastUse).filter((line) => !own(line)).length, 0, `model use ${previousDefault}`);
+  }
+  return [{ file, raw, next: kept.every(isBlankText) ? null : fromLf(`${kept.join("\n")}
+`, layoutOf(raw)) }];
+}
+function remove5(config, previousDefault) {
+  const changes = removal5(config, previousDefault);
+  applyChanges(config, TOOL5, changes);
+  return { path: toolPaths(config).crushrc, changed: changes.length > 0 };
+}
+function hasOwnEntries5(config) {
+  return removal5(config, null).length > 0;
+}
+
+// cli/src/writers/goose.ts
+var goose_exports = {};
+__export(goose_exports, {
+  currentDefault: () => currentDefault6,
+  hasOwnEntries: () => hasOwnEntries6,
+  remove: () => remove6,
+  scalarValue: () => scalarValue,
+  startCommand: () => startCommand2,
+  withOwnDefault: () => withOwnDefault,
+  write: () => write6,
+  yamlScalar: () => yamlScalar
+});
+import { mkdirSync as mkdirSync8 } from "node:fs";
+
+// cli/src/tool-entries.ts
+var QWEN_PROTOCOL = "openai";
+var QWEN_SETTINGS_VERSION = 4;
+var GOOSE_ENGINE = "openai";
+var OPENHANDS_MODEL_PREFIX = "openai/";
+var OPENHANDS_AGENT_USAGE = "agent";
+var OPENHANDS_CONDENSER_USAGE = "condenser";
+function qwenModel(source, model) {
+  return {
+    id: model.id,
+    name: model.name,
+    description: PROVIDER_NAME,
+    envKey: API_KEY_ENV,
+    baseUrl: source.base,
+    generationConfig: { contextWindowSize: model.context, samplingParams: { max_tokens: model.maxOutput } }
+  };
+}
+function gooseProvider(source, models2) {
+  return {
+    name: source.provider,
+    engine: GOOSE_ENGINE,
+    display_name: PROVIDER_NAME,
+    description: `${PROVIDER_NAME} models`,
+    base_url: source.base,
+    models: models2.map((model) => ({ name: model.id, context_limit: model.context, reasoning: true })),
+    headers: { Authorization: `Bearer ${source.key}` },
+    supports_streaming: true,
+    requires_auth: false
+  };
+}
+function openhandsLlm(source, model, usage) {
+  return {
+    model: `${OPENHANDS_MODEL_PREFIX}${model.id}`,
+    api_key: source.key,
+    base_url: source.base,
+    usage_id: usage,
+    max_input_tokens: model.context,
+    max_output_tokens: model.maxOutput
+  };
+}
+function openhandsAgent(source, model) {
+  return {
+    llm: openhandsLlm(source, model, OPENHANDS_AGENT_USAGE),
+    system_prompt_kwargs: { cli_mode: true },
+    condenser: { kind: "LLMSummarizingCondenser", llm: openhandsLlm(source, model, OPENHANDS_CONDENSER_USAGE), max_size: 80, keep_first: 4 },
+    kind: "Agent"
+  };
+}
+
+// cli/src/writers/goose.ts
+var TOOL6 = "goose";
+var ACTIVE_PROVIDER = "active_provider";
+var PROVIDERS = "providers";
+var LEGACY_PROVIDER = "GOOSE_PROVIDER";
+var LEGACY_MODEL = "GOOSE_MODEL";
+var MODEL_FIELD = "model";
+var EMPTY_FLOW_MAP = "{}";
+var DEFAULT_INDENT = "  ";
+var PROVIDER_SEPARATOR2 = "/";
+var TOP_LEVEL_KEY = /^([A-Za-z0-9_][^:#\s]*)[ \t]*:(.*)$/;
+var NESTED_KEY = /^([ \t]+)([^\s:#][^:#]*?)[ \t]*:(.*)$/;
+var PLAIN_SCALAR = /^[A-Za-z][A-Za-z0-9._/-]*$/;
+var RESERVED_SCALARS = ["true", "false", "yes", "no", "on", "off", "null", "y", "n"];
+function yamlScalar(value) {
+  if (PLAIN_SCALAR.test(value) && !RESERVED_SCALARS.includes(value.toLowerCase())) return value;
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function withoutComment(value) {
+  const hash = value.search(/[ \t]#/);
+  return (hash === -1 ? value : value.slice(0, hash)).trim();
+}
+function scalarValue(raw) {
+  const value = raw.trim();
+  if (value.startsWith("'")) {
+    const close = value.lastIndexOf("'");
+    return close > 0 ? value.slice(1, close).replaceAll("''", "'") : null;
+  }
+  if (value.startsWith('"')) {
+    const close = value.lastIndexOf('"');
+    return close > 0 ? value.slice(1, close).replace(/\\(["\\])/g, "$1") : null;
+  }
+  const plain = withoutComment(value);
+  return plain === "" || /^[[{|>&*!]/.test(plain) ? null : plain;
+}
+function isContentLine(line) {
+  return !isBlankText(line) && !line.trimStart().startsWith("#");
+}
+function topLevelAt(lines, key) {
+  return lines.findIndex((line) => TOP_LEVEL_KEY.exec(line)?.[1] === key);
+}
+function topLevelValue(lines, key) {
+  const at = topLevelAt(lines, key);
+  const match = at === -1 ? null : TOP_LEVEL_KEY.exec(lines[at]);
+  return match === null ? null : scalarValue(match[2]);
+}
+function blockEnd(lines, header) {
+  let end = header + 1;
+  for (let index = header + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!isContentLine(line)) continue;
+    if (!/^[ \t]/.test(line)) break;
+    end = index + 1;
+  }
+  return end;
+}
+function providersBlock(lines) {
+  const header = topLevelAt(lines, PROVIDERS);
+  if (header === -1) return null;
+  const inline = withoutComment(TOP_LEVEL_KEY.exec(lines[header])?.[2] ?? "");
+  return { header, end: inline === "" ? blockEnd(lines, header) : header + 1, inline };
+}
+function indentOf(line) {
+  return /^[ \t]*/.exec(line)?.[0] ?? "";
+}
+function childIndent(lines, block) {
+  const first = block === null ? void 0 : lines.slice(block.header + 1, block.end).find(isContentLine);
+  return first === void 0 ? DEFAULT_INDENT : indentOf(first);
+}
+function children(lines, block) {
+  if (block.inline !== "") return [];
+  const indent = childIndent(lines, block);
+  const found = [];
+  for (let index = block.header + 1; index < block.end; index += 1) {
+    const match = NESTED_KEY.exec(lines[index]);
+    if (match !== null && match[1] === indent) found.push({ name: match[2], start: index, end: index + 1 });
+    else if (found.length > 0 && isContentLine(lines[index])) found[found.length - 1].end = index + 1;
+  }
+  return found;
+}
+function findChild(lines, name) {
+  const block = providersBlock(lines);
+  return block === null ? null : children(lines, block).find((child) => child.name === name) ?? null;
+}
+function modelLineOf(lines, child) {
+  for (let index = child.start + 1; index < child.end; index += 1) {
+    if (NESTED_KEY.exec(lines[index])?.[2] === MODEL_FIELD) return index;
+  }
+  return -1;
+}
+function modelOf(lines, child) {
+  const at = child === null ? -1 : modelLineOf(lines, child);
+  const match = at === -1 ? null : NESTED_KEY.exec(lines[at]);
+  return match === null ? null : scalarValue(match[3]);
+}
+function defaultIn2(lines) {
+  const provider = topLevelValue(lines, ACTIVE_PROVIDER) || topLevelValue(lines, LEGACY_PROVIDER);
+  if (!provider) return null;
+  return { provider, model: modelOf(lines, findChild(lines, provider)) || topLevelValue(lines, LEGACY_MODEL) || null };
+}
+function defaultLabel(value) {
+  if (value === null) return null;
+  return value.model === null ? value.provider : `${value.provider}${PROVIDER_SEPARATOR2}${value.model}`;
+}
+function modelLine2(indent, model) {
+  return `${indent}${indent}${MODEL_FIELD}: ${yamlScalar(model)}`;
+}
+function childLines(indent, name, model) {
+  return [`${indent}${name}:`, `${indent}${indent}enabled: true`, modelLine2(indent, model), `${indent}${indent}configured: true`];
+}
+function withChild(lines, name, model) {
+  const block = providersBlock(lines);
+  if (block === null) return [...lines, `${PROVIDERS}:`, ...childLines(DEFAULT_INDENT, name, model)];
+  if (block.inline !== "") {
+    if (block.inline !== EMPTY_FLOW_MAP) throw new Error(`its ${PROVIDERS} entry is not a block the setup can edit`);
+    return [...lines.slice(0, block.header), `${PROVIDERS}:`, ...childLines(DEFAULT_INDENT, name, model), ...lines.slice(block.header + 1)];
+  }
+  const own = childLines(childIndent(lines, block), name, model);
+  const existing = children(lines, block).find((child) => child.name === name);
+  if (existing === void 0) return [...lines.slice(0, block.end), ...own, ...lines.slice(block.end)];
+  return [...lines.slice(0, existing.start), ...own, ...lines.slice(existing.end)];
+}
+function withActiveProvider(lines, provider, position) {
+  const line = `${ACTIVE_PROVIDER}: ${yamlScalar(provider)}`;
+  const at = topLevelAt(lines, ACTIVE_PROVIDER);
+  if (at !== -1) return [...lines.slice(0, at), line, ...lines.slice(at + 1)];
+  const block = providersBlock(lines);
+  const insertAt = position ?? (block === null ? lines.length : block.header);
+  return [...lines.slice(0, insertAt), line, ...lines.slice(insertAt)];
+}
+function withOwnDefault(content, config) {
+  const lines = withChild(withActiveProvider(splitLines(content), config.provider), config.provider, config.model);
+  return `${lines.join("\n")}
+`;
+}
+function startCommand2(config) {
+  return `goose session --provider ${config.provider} --model ${config.model}`;
+}
+function writeDefault(config) {
+  const file = toolPaths(config).gooseConfig;
+  const raw = readText(file);
+  let updated;
+  try {
+    updated = withOwnDefault(toLf(raw ?? ""), config);
+  } catch (error) {
+    throw new Error(`${file}: ${error instanceof Error ? error.message : String(error)}; pick the model with "goose configure"`);
+  }
+  saveText(config, TOOL6, file, fromLf(updated, layoutOf(raw ?? "")), raw);
+}
+function write6(config, options) {
+  const paths = toolPaths(config);
+  mkdirSync8(pathsFor(config.platform).dirname(paths.gooseProvider), { recursive: true });
+  const existing = readText(paths.gooseProvider);
+  saveText(config, TOOL6, paths.gooseProvider, jsonText(gooseProvider(config, config.models), layoutOf(existing ?? "")), existing);
+  setMode(paths.gooseProvider, 384, config.platform);
+  if (options.setDefault) writeDefault(config);
+  const startsOnOwnModel = currentDefault6(config)?.startsWith(`${config.provider}${PROVIDER_SEPARATOR2}`) ?? false;
+  return { path: paths.gooseProvider, next: startsOnOwnModel ? "goose session" : startCommand2(config) };
+}
+function currentDefault6(config) {
+  let raw;
+  try {
+    raw = readText(toolPaths(config).gooseConfig);
+  } catch {
+    return null;
+  }
+  return raw === null ? null : defaultLabel(defaultIn2(splitLines(toLf(raw))));
+}
+function parsedDefault(value) {
+  const slash = value.indexOf(PROVIDER_SEPARATOR2);
+  return slash <= 0 ? { provider: value, model: null } : { provider: value.slice(0, slash), model: value.slice(slash + 1) };
+}
+function withModelOf(lines, provider, model) {
+  const child = findChild(lines, provider);
+  if (child === null) return withChild(lines, provider, model);
+  const line = modelLine2(childIndent(lines, providersBlock(lines)), model);
+  const at = modelLineOf(lines, child);
+  if (at === -1) return [...lines.slice(0, child.end), line, ...lines.slice(child.end)];
+  return [...lines.slice(0, at), line, ...lines.slice(at + 1)];
+}
+function withPreviousDefault(lines, position, previousDefault) {
+  if (defaultLabel(defaultIn2(lines)) === previousDefault) return [...lines];
+  const previous = parsedDefault(previousDefault);
+  const restored = withActiveProvider(lines, previous.provider, Math.min(position, lines.length));
+  if (previous.model === null || defaultLabel(defaultIn2(restored)) === previousDefault) return restored;
+  return withModelOf(restored, previous.provider, previous.model);
+}
+function withoutChild(lines, name) {
+  const child = findChild(lines, name);
+  if (child === null) return [...lines];
+  const kept = [...lines.slice(0, child.start), ...lines.slice(child.end)];
+  const block = providersBlock(kept);
+  if (block === null || children(kept, block).length > 0) return kept;
+  return [...kept.slice(0, block.header), ...kept.slice(block.end)];
+}
+function withoutOwnDefault(lines, provider, previousDefault) {
+  const at = topLevelAt(lines, ACTIVE_PROVIDER);
+  if (at === -1 || topLevelValue(lines, ACTIVE_PROVIDER) !== provider) return [...lines];
+  const kept = [...lines.slice(0, at), ...lines.slice(at + 1)];
+  return previousDefault === null ? kept : withPreviousDefault(kept, at, previousDefault);
+}
+function configRemoval(config, previousDefault) {
+  const file = toolPaths(config).gooseConfig;
+  const raw = readText(file);
+  if (raw === null) return [];
+  const lines = splitLines(toLf(raw));
+  const kept = withoutChild(withoutOwnDefault(lines, config.provider, previousDefault), config.provider);
+  if (kept.join("\n") === lines.join("\n")) return [];
+  return [{ file, raw, next: kept.every(isBlankText) ? null : fromLf(`${kept.join("\n")}
+`, layoutOf(raw)) }];
+}
+function providerRemoval(config) {
+  const file = toolPaths(config).gooseProvider;
+  if (!isFile(file)) return [];
+  try {
+    readJsonDocument(file);
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`${file} is not JSON Goose can read; fix it, then run "unrestricted remove" again`);
+    throw error;
+  }
+  return [{ file, raw: readText(file), next: null }];
+}
+function removal6(config, previousDefault) {
+  return [...providerRemoval(config), ...configRemoval(config, previousDefault)];
+}
+function remove6(config, previousDefault) {
+  const changes = removal6(config, previousDefault);
+  applyChanges(config, TOOL6, changes);
+  return { path: changes[0]?.file ?? toolPaths(config).gooseProvider, changed: changes.length > 0 };
+}
+function hasOwnEntries6(config) {
+  return removal6(config, null).length > 0;
+}
 
 // cli/src/writers/opencode.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
+var opencode_exports = {};
+__export(opencode_exports, {
+  currentDefault: () => currentDefault7,
+  hasOwnEntries: () => hasOwnEntries7,
+  remove: () => remove7,
+  write: () => write7
+});
+import { mkdirSync as mkdirSync9 } from "node:fs";
 
 // node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -3574,6 +4489,7 @@ var SyntaxKind;
 var parse2 = parse;
 var parseTree2 = parseTree;
 var findNodeAtLocation2 = findNodeAtLocation;
+var visit2 = visit;
 var ParseErrorCode;
 (function(ParseErrorCode2) {
   ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
@@ -3626,6 +4542,19 @@ function parseJsoncObject(text) {
   if (errors.length > 0 || typeof value !== "object" || value === null || Array.isArray(value)) return null;
   return value;
 }
+function hasComments(text) {
+  let found = false;
+  visit2(
+    text,
+    {
+      onComment: () => {
+        found = true;
+      }
+    },
+    PARSE_OPTIONS
+  );
+  return found;
+}
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3659,7 +4588,7 @@ function lineBreakAt(text, offset) {
   if (text.startsWith("\r\n", offset)) return 2;
   return text[offset] === "\n" ? 1 : 0;
 }
-function removal(text, start2, end) {
+function removal7(text, start2, end) {
   let from = start2;
   while (isBlank(text[from - 1])) from -= 1;
   let to = end;
@@ -3677,20 +4606,22 @@ function removeJsonc(text, path) {
   if (property === void 0 || property.type !== "property" || siblings === void 0) return text;
   const end = property.offset + property.length;
   const following = nextToken(text, end);
-  if (text[following.offset] === ",") return applyEdits(text, [removal(text, property.offset, following.end)]);
+  if (text[following.offset] === ",") return applyEdits(text, [removal7(text, property.offset, following.end)]);
   const index = siblings.indexOf(property);
-  if (index <= 0) return applyEdits(text, [removal(text, property.offset, end)]);
+  if (index <= 0) return applyEdits(text, [removal7(text, property.offset, end)]);
   const previous = siblings[index - 1];
   const comma = nextToken(text, previous.offset + previous.length);
-  return applyEdits(text, [{ offset: comma.offset, length: comma.end - comma.offset, content: "" }, removal(text, property.offset, end)]);
+  return applyEdits(text, [{ offset: comma.offset, length: comma.end - comma.offset, content: "" }, removal7(text, property.offset, end)]);
 }
 
 // cli/src/writers/opencode.ts
+var TOOL7 = "opencode";
 var SCHEMA = "https://opencode.ai/config.json";
 var PROVIDER_PACKAGE = "@ai-sdk/openai-compatible";
-var PROVIDER_NAME = "unrestricted.sh";
+var PROVIDER_NAME2 = "unrestricted.sh";
 var OWN_PROVIDER_KEYS = ["npm", "name"];
 var OWN_OPTION_KEYS = ["baseURL", "apiKey"];
+var MODEL_PATH = ["model"];
 var FIRST = () => 0;
 var AFTER_SCHEMA = (keys) => keys.indexOf("$schema") + 1;
 function withoutOwnModels(models2, config) {
@@ -3706,34 +4637,38 @@ function ownModels(config) {
 function ownProvider(config) {
   return {
     npm: PROVIDER_PACKAGE,
-    name: PROVIDER_NAME,
+    name: PROVIDER_NAME2,
     options: { baseURL: config.base, apiKey: config.key },
     models: ownModels(config)
   };
 }
-function isFile3(path) {
-  try {
-    return statSync3(path).isFile();
-  } catch {
-    return false;
-  }
+function defaultModel(settings) {
+  const model = settings.model;
+  return typeof model === "string" && model !== "" ? model : null;
 }
-function writeJson(config, file) {
-  const { value: settings, layout } = readJsonDocument(file);
-  const schema = settings.$schema;
-  settings.$schema = typeof schema === "string" && schema ? schema : SCHEMA;
+function hasOwnDefault(settings, owner) {
+  const model = defaultModel(settings);
+  return model !== null && isOwnDefault(model, owner);
+}
+function hasForeignDefault(settings, owner) {
+  const model = defaultModel(settings);
+  return model !== null && !isOwnDefault(model, owner);
+}
+function writeJson(config, file, options) {
+  const document = readJsonDocument(file);
+  const settings = document.raw === null || isBlankText(document.raw) ? { $schema: SCHEMA } : document.value;
   const providers = asObject(settings.provider);
   settings.provider = providers;
   const existing = asObject(providers[config.provider]);
   providers[config.provider] = {
     ...existing,
     npm: PROVIDER_PACKAGE,
-    name: PROVIDER_NAME,
+    name: PROVIDER_NAME2,
     options: { ...asObject(existing.options), baseURL: config.base, apiKey: config.key },
     models: { ...withoutOwnModels(asObject(existing.models), config), ...ownModels(config) }
   };
-  settings.model = `${config.provider}/${config.model}`;
-  writeJsonDocument(file, settings, layout);
+  if (options.setDefault) settings.model = `${config.provider}/${config.model}`;
+  saveText(config, TOOL7, file, jsonText(settings, document.layout), document.raw);
   setMode(file, 384, config.platform);
   return { path: file, next: "opencode" };
 }
@@ -3760,7 +4695,7 @@ function withOwnProvider(text, config, settings) {
   const existing = providers[config.provider];
   if (!isJsonObject(existing)) return setJsonc(text, path, ownProvider(config), FIRST);
   let updated = setJsonc(text, [...path, "npm"], PROVIDER_PACKAGE, FIRST);
-  updated = setJsonc(updated, [...path, "name"], PROVIDER_NAME, (keys) => keys.indexOf("npm") + 1);
+  updated = setJsonc(updated, [...path, "name"], PROVIDER_NAME2, (keys) => keys.indexOf("npm") + 1);
   if (isJsonObject(existing.options)) {
     updated = setJsonc(updated, [...path, "options", "baseURL"], config.base, FIRST);
     updated = setJsonc(updated, [...path, "options", "apiKey"], config.key, (keys) => keys.indexOf("baseURL") + 1);
@@ -3770,29 +4705,23 @@ function withOwnProvider(text, config, settings) {
   if (isJsonObject(existing.models)) return withOwnModels(updated, config, existing.models);
   return setJsonc(updated, [...path, "models"], ownModels(config), FIRST);
 }
-function ownJsonPaths(settings, config) {
-  const paths = [];
-  const model = settings.model;
-  const prefix = `${config.provider}/`;
-  if (typeof model === "string" && model.startsWith(prefix) && isOwnModel(model.slice(prefix.length), config)) paths.push(["model"]);
+function ownProviderPaths(settings, owner) {
   const providers = asObject(settings.provider);
-  const entry = providers[config.provider];
-  if (!isJsonObject(entry)) return paths;
-  const path = ["provider", config.provider];
+  const entry = providers[owner.provider];
+  if (!isJsonObject(entry)) return [];
+  const path = ["provider", owner.provider];
   const options = entry.options;
   const models2 = entry.models;
   const keptOptions = isJsonObject(options) ? Object.keys(options).filter((key) => !OWN_OPTION_KEYS.includes(key)) : [];
-  const keptModels = isJsonObject(models2) ? Object.keys(models2).filter((id) => !isOwnModel(id, config)) : [];
+  const keptModels = isJsonObject(models2) ? Object.keys(models2).filter((id) => !isOwnModel(id, owner)) : [];
   const keptKeys = Object.keys(entry).filter((key) => {
     if (OWN_PROVIDER_KEYS.includes(key)) return false;
     if (key === "options" && isJsonObject(options)) return keptOptions.length > 0;
     if (key === "models" && isJsonObject(models2)) return keptModels.length > 0;
     return true;
   });
-  if (keptKeys.length === 0) {
-    paths.push(Object.keys(providers).length === 1 ? ["provider"] : path);
-    return paths;
-  }
+  if (keptKeys.length === 0) return [Object.keys(providers).length === 1 ? ["provider"] : path];
+  const paths = [];
   for (const key of OWN_PROVIDER_KEYS) if (key in entry) paths.push([...path, key]);
   if (isJsonObject(options)) {
     if (keptOptions.length === 0) paths.push([...path, "options"]);
@@ -3800,51 +4729,227 @@ function ownJsonPaths(settings, config) {
   }
   if (isJsonObject(models2)) {
     if (keptModels.length === 0) paths.push([...path, "models"]);
-    else for (const id of Object.keys(models2)) if (isOwnModel(id, config)) paths.push([...path, "models", id]);
+    else for (const id of Object.keys(models2)) if (isOwnModel(id, owner)) paths.push([...path, "models", id]);
   }
   return paths;
 }
-function withoutOwnJsonEntries(file, config) {
-  if (!isFile3(file)) return void 0;
-  const raw = readFileSync9(file, "utf8");
+function withoutOwnJsonEntries(config, file, options) {
+  if (!isFile(file)) return void 0;
+  const raw = readText(file) ?? "";
   const original = withoutBom(raw);
-  const settings = original.trim() === "" ? {} : parseJsoncObject(original);
+  const settings = isBlankText(original) ? {} : parseJsoncObject(original);
   if (settings === null) return `${file} could not be read, so the setup left it as it is; OpenCode reads ${OPENCODE_JSONC_FILE} after it`;
+  const paths = ownProviderPaths(settings, config);
+  if (options.setDefault && hasOwnDefault(settings, config)) paths.push(MODEL_PATH);
   let updated = original;
-  for (const path of ownJsonPaths(settings, config)) updated = removeJsonc(updated, path);
-  if (updated !== original) writeFileSync10(file, withBom(updated, layoutOf(raw)));
+  for (const path of paths) updated = removeJsonc(updated, path);
+  saveText(config, TOOL7, file, withBom(updated, layoutOf(raw)), raw);
   return void 0;
 }
-function writeJsonc(config, file, jsonFile) {
-  const raw = readFileSync9(file, "utf8");
+function writeJsonc(config, file, jsonFile, options) {
+  const raw = readText(file) ?? "";
   const layout = layoutOf(raw);
   const original = withoutBom(raw);
-  const text = original.trim() === "" ? `{}${layout.eol}` : original;
+  const blank = isBlankText(original);
+  const text = blank ? `{}${layout.eol}` : original;
   const settings = parseJsoncObject(text);
   if (settings === null) throw new Error(`${file} is not a JSON object OpenCode can read; fix it, then run the setup again`);
-  const schema = settings.$schema;
-  let updated = typeof schema === "string" && schema ? text : setJsonc(text, ["$schema"], SCHEMA, FIRST);
+  let updated = blank ? setJsonc(text, ["$schema"], SCHEMA, FIRST) : text;
   updated = withOwnProvider(updated, config, settings);
-  updated = setJsonc(updated, ["model"], `${config.provider}/${config.model}`, AFTER_SCHEMA);
-  const output = withBom(updated, layout);
-  if (output !== raw) writeFileSync10(file, output);
+  if (options.setDefault) updated = setJsonc(updated, MODEL_PATH, `${config.provider}/${config.model}`, AFTER_SCHEMA);
+  saveText(config, TOOL7, file, withBom(updated, layout), raw);
   setMode(file, 384, config.platform);
-  const hint = withoutOwnJsonEntries(jsonFile, config);
+  const hint = withoutOwnJsonEntries(config, jsonFile, options);
   return hint === void 0 ? { path: file, next: "opencode" } : { path: file, next: "opencode", hint };
 }
-function write6(config) {
+function write7(config, options) {
+  const paths = toolPaths(config);
+  mkdirSync9(paths.opencodeDir, { recursive: true });
+  if (isFile(paths.opencodeJsonc)) return writeJsonc(config, paths.opencodeJsonc, paths.opencodeJson, options);
+  return writeJson(config, paths.opencodeJson, options);
+}
+function settingsIn(file) {
+  try {
+    if (!isFile(file)) return null;
+    const text = withoutBom(readText(file) ?? "");
+    return isBlankText(text) ? {} : parseJsoncObject(text);
+  } catch {
+    return null;
+  }
+}
+function currentDefault7(config) {
+  const paths = toolPaths(config);
+  for (const file of [paths.opencodeJsonc, paths.opencodeJson]) {
+    const settings = settingsIn(file);
+    const model = settings === null ? null : defaultModel(settings);
+    if (model !== null) return model;
+  }
+  return null;
+}
+function readSettingsFile(file) {
+  if (!isFile(file)) return null;
+  const raw = readText(file) ?? "";
+  const text = withoutBom(raw);
+  const settings = isBlankText(text) ? {} : parseJsoncObject(text);
+  if (settings === null) throw new Error(`${file} is not a JSON object OpenCode can read; fix it, then run "unrestricted remove" again`);
+  return { file, raw, text, settings };
+}
+function isBareText(text) {
+  const settings = parseJsoncObject(text);
+  return settings !== null && isBareDocument(settings) && !hasComments(text);
+}
+function removal8(config, previousDefault) {
+  const paths = toolPaths(config);
+  const files = [paths.opencodeJsonc, paths.opencodeJson].map(readSettingsFile).filter((entry) => entry !== null);
+  const holder = files.find((entry) => defaultModel(entry.settings) !== null);
+  const restore = previousDefault !== null && holder !== void 0 && hasOwnDefault(holder.settings, config) && !files.some((entry) => hasForeignDefault(entry.settings, config));
+  const changes = [];
+  for (const entry of files) {
+    let updated = entry.text;
+    for (const path of ownProviderPaths(entry.settings, config)) updated = removeJsonc(updated, path);
+    if (restore && entry === holder && previousDefault !== null) updated = setJsonc(updated, MODEL_PATH, previousDefault);
+    else if (hasOwnDefault(entry.settings, config)) updated = removeJsonc(updated, MODEL_PATH);
+    if (updated === entry.text) continue;
+    changes.push({ file: entry.file, raw: entry.raw, next: isBareText(updated) ? null : withBom(updated, layoutOf(entry.raw)) });
+  }
+  return changes;
+}
+function remove7(config, previousDefault) {
+  const changes = removal8(config, previousDefault);
+  applyChanges(config, TOOL7, changes);
+  const paths = toolPaths(config);
+  const main = isFile(paths.opencodeJsonc) ? paths.opencodeJsonc : paths.opencodeJson;
+  return { path: changes[0]?.file ?? main, changed: changes.length > 0 };
+}
+function hasOwnEntries7(config) {
+  return removal8(config, null).length > 0;
+}
+
+// cli/src/writers/openhands.ts
+var openhands_exports = {};
+__export(openhands_exports, {
+  currentDefault: () => currentDefault8,
+  hasOwnEntries: () => hasOwnEntries8,
+  remove: () => remove8,
+  write: () => write8
+});
+import { mkdirSync as mkdirSync10 } from "node:fs";
+var TOOL8 = "openhands";
+function withoutTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function ownModelId(value, owner) {
+  const llm = asObject(value);
+  const { model, base_url: base } = llm;
+  if (typeof model !== "string" || !model.startsWith(OPENHANDS_MODEL_PREFIX) || typeof base !== "string") return null;
+  const id = model.slice(OPENHANDS_MODEL_PREFIX.length);
+  return isOwnModel(id, owner) && withoutTrailingSlashes(base) === withoutTrailingSlashes(owner.base) ? id : null;
+}
+function modelFor(config, id) {
+  return config.models.find((model) => model.id === id) ?? { id, name: config.modelName, context: config.context, maxOutput: config.maxOutput };
+}
+function readDocument(file, command) {
+  try {
+    return readJsonDocument(file);
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`${file} is not JSON OpenHands can read; fix it, then run ${command} again`);
+    throw error;
+  }
+}
+function withOwnLlm(settings, config, model) {
+  const next = { ...settings, llm: openhandsLlm(config, model, OPENHANDS_AGENT_USAGE) };
+  const condenser = settings.condenser;
+  if (isJsonObject(condenser) && isJsonObject(condenser.llm)) next.condenser = { ...condenser, llm: openhandsLlm(config, model, OPENHANDS_CONDENSER_USAGE) };
+  return next;
+}
+function write8(config, options) {
   const paths = toolPaths(config);
-  mkdirSync8(paths.opencodeDir, { recursive: true });
-  if (isFile3(paths.opencodeJsonc)) return writeJsonc(config, paths.opencodeJsonc, paths.opencodeJson);
-  return writeJson(config, paths.opencodeJson);
+  const file = paths.openhandsSettings;
+  mkdirSync10(paths.openhandsDir, { recursive: true });
+  const document = readDocument(file, "the setup");
+  const settings = document.value;
+  const current = ownModelId(settings.llm, config);
+  if (!options.setDefault && current === null) return { path: file, next: "openhands" };
+  const model = modelFor(config, options.setDefault ? config.model : current ?? config.model);
+  const fresh = Object.keys(settings).length === 0;
+  const next = fresh ? openhandsAgent(config, model) : withOwnLlm(settings, config, model);
+  saveText(config, TOOL8, file, jsonText(next, document.layout), document.raw);
+  setMode(file, 384, config.platform);
+  return { path: file, next: "openhands" };
+}
+function currentDefault8(config) {
+  let settings;
+  try {
+    settings = readJsonDocument(toolPaths(config).openhandsSettings).value;
+  } catch {
+    return null;
+  }
+  const model = asObject(settings.llm).model;
+  if (typeof model !== "string" || model === "") return null;
+  const own = ownModelId(settings.llm, config);
+  return own === null ? model : `${config.provider}/${own}`;
+}
+function earlierSettings(config, file, previousDefault) {
+  for (const backup of backupsOf(config, TOOL8, file).reverse()) {
+    let settings;
+    try {
+      settings = readJsonDocument(backup).value;
+    } catch {
+      continue;
+    }
+    if (asObject(settings.llm).model === previousDefault && ownModelId(settings.llm, config) === null) return settings;
+  }
+  return null;
+}
+function withEarlierLlm(settings, earlier, owner) {
+  const next = { ...settings, llm: earlier.llm };
+  const condenser = asObject(settings.condenser);
+  if (ownModelId(condenser.llm, owner) === null) return next;
+  const earlierCondenser = asObject(earlier.condenser).llm;
+  next.condenser = { ...condenser, llm: isJsonObject(earlierCondenser) ? earlierCondenser : { ...asObject(earlier.llm), usage_id: OPENHANDS_CONDENSER_USAGE } };
+  return next;
+}
+function withAgentCondenser(settings) {
+  return { ...settings, condenser: { ...asObject(settings.condenser), llm: { ...asObject(settings.llm), usage_id: OPENHANDS_CONDENSER_USAGE } } };
+}
+function removal9(config, previousDefault) {
+  const file = toolPaths(config).openhandsSettings;
+  const document = readDocument(file, '"unrestricted remove"');
+  if (document.raw === null) return [];
+  const settings = document.value;
+  const ownAgent = ownModelId(settings.llm, config) !== null;
+  const ownCondenser = ownModelId(asObject(settings.condenser).llm, config) !== null;
+  if (!ownAgent && !ownCondenser) return [];
+  if (!ownAgent) return [{ file, raw: document.raw, next: jsonText(withAgentCondenser(settings), document.layout) }];
+  const earlier = previousDefault === null ? null : earlierSettings(config, file, previousDefault);
+  if (earlier === null) return [{ file, raw: document.raw, next: null }];
+  return [{ file, raw: document.raw, next: jsonText(withEarlierLlm(settings, earlier, config), document.layout) }];
+}
+function remove8(config, previousDefault) {
+  const changes = removal9(config, previousDefault);
+  applyChanges(config, TOOL8, changes);
+  return { path: toolPaths(config).openhandsSettings, changed: changes.length > 0 };
+}
+function hasOwnEntries8(config) {
+  return removal9(config, null).length > 0;
 }
 
 // cli/src/writers/pi.ts
-import { mkdirSync as mkdirSync9 } from "node:fs";
-var PROVIDER_NAME2 = "unrestricted.sh";
-function isOwnEntry(entry, config) {
+var pi_exports = {};
+__export(pi_exports, {
+  currentDefault: () => currentDefault9,
+  hasOwnEntries: () => hasOwnEntries9,
+  remove: () => remove9,
+  write: () => write9
+});
+import { mkdirSync as mkdirSync11 } from "node:fs";
+var TOOL9 = "pi";
+var PROVIDER_NAME3 = "unrestricted.sh";
+var OWN_PROVIDER_KEYS2 = ["name", "baseUrl", "api", "apiKey"];
+var PROVIDER_SEPARATOR3 = "/";
+function isOwnEntry(entry, owner) {
   const id = asObject(entry).id;
-  return typeof id === "string" && isOwnModel(id, config);
+  return typeof id === "string" && isOwnModel(id, owner);
 }
 function withOwnModels2(existing, config) {
   const models2 = Array.isArray(existing) ? existing : [];
@@ -3859,7 +4964,7 @@ function withOwnProvider2(document, config) {
   const existing = asObject(providers[config.provider]);
   const provider = {
     ...existing,
-    name: PROVIDER_NAME2,
+    name: PROVIDER_NAME3,
     baseUrl: config.base,
     api: PI_API,
     apiKey: config.key,
@@ -3867,33 +4972,423 @@ function withOwnProvider2(document, config) {
   };
   return { ...document, providers: { ...providers, [config.provider]: provider } };
 }
-function write7(config) {
+function changeTo2(file, document, value) {
+  return { file, raw: document.raw, next: isBareDocument(value) && document.raw !== null ? null : jsonText(value, document.layout) };
+}
+function write9(config, options) {
   const paths = toolPaths(config);
-  mkdirSync9(paths.piAgentDir, { recursive: true });
+  mkdirSync11(paths.piAgentDir, { recursive: true });
   const models2 = readJsonDocument(paths.piModels);
-  const settings = readJsonDocument(paths.piSettings);
+  const settings = options.setDefault ? readJsonDocument(paths.piSettings) : null;
+  const changes = [{ file: paths.piModels, raw: models2.raw, next: jsonText(withOwnProvider2(models2.value, config), models2.layout) }];
+  if (settings !== null) {
+    const value = { ...settings.value, defaultProvider: config.provider, defaultModel: config.model };
+    changes.push({ file: paths.piSettings, raw: settings.raw, next: jsonText(value, settings.layout) });
+  }
+  applyChanges(config, TOOL9, changes);
   setMode(paths.piModels, 384, config.platform);
-  writeJsonDocument(paths.piModels, withOwnProvider2(models2.value, config), models2.layout);
-  writeJsonDocument(
-    paths.piSettings,
-    { ...settings.value, defaultProvider: config.provider, defaultModel: config.model },
-    settings.layout
-  );
   return { path: paths.piModels, next: "pi" };
 }
+function readSettings(file) {
+  try {
+    return readJsonDocument(file).value;
+  } catch {
+    return null;
+  }
+}
+function currentDefault9(config) {
+  const settings = readSettings(toolPaths(config).piSettings);
+  if (settings === null) return null;
+  const { defaultProvider: provider, defaultModel: model } = settings;
+  if (typeof model !== "string" || model === "") return null;
+  return typeof provider === "string" && provider !== "" ? `${provider}${PROVIDER_SEPARATOR3}${model}` : model;
+}
+function withoutOwnProvider(document, owner) {
+  const providers = document.providers;
+  if (!isJsonObject(providers)) return null;
+  const entry = providers[owner.provider];
+  if (!isJsonObject(entry)) return null;
+  const kept = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (OWN_PROVIDER_KEYS2.includes(key)) continue;
+    if (key === "models" && Array.isArray(value)) {
+      const models2 = value.filter((model) => !isOwnEntry(model, owner));
+      if (models2.length > 0) kept.models = models2;
+      continue;
+    }
+    kept[key] = value;
+  }
+  if (JSON.stringify(kept) === JSON.stringify(entry)) return null;
+  const others = { ...providers };
+  if (Object.keys(kept).length > 0) others[owner.provider] = kept;
+  else delete others[owner.provider];
+  const next = { ...document, providers: others };
+  if (Object.keys(others).length === 0) delete next.providers;
+  return next;
+}
+function withPreviousDefault2(settings, previousDefault) {
+  const next = { ...settings };
+  const slash = previousDefault === null ? -1 : previousDefault.indexOf(PROVIDER_SEPARATOR3);
+  if (previousDefault === null) {
+    delete next.defaultProvider;
+    delete next.defaultModel;
+  } else if (slash > 0) {
+    next.defaultProvider = previousDefault.slice(0, slash);
+    next.defaultModel = previousDefault.slice(slash + 1);
+  } else {
+    delete next.defaultProvider;
+    next.defaultModel = previousDefault;
+  }
+  return next;
+}
+function hasOwnDefault2(settings, owner) {
+  const { defaultProvider: provider, defaultModel: model } = settings;
+  return provider === owner.provider && typeof model === "string" && isOwnModel(model, owner);
+}
+function readPiDocument(file) {
+  try {
+    return readJsonDocument(file);
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new Error(`${file} is not JSON Pi can read; fix it, then run "unrestricted remove" again`);
+    throw error;
+  }
+}
+function removal10(config, previousDefault) {
+  const paths = toolPaths(config);
+  const changes = [];
+  const models2 = readPiDocument(paths.piModels);
+  const cleaned = models2.raw === null ? null : withoutOwnProvider(models2.value, config);
+  if (cleaned !== null) changes.push(changeTo2(paths.piModels, models2, cleaned));
+  const settings = readPiDocument(paths.piSettings);
+  if (settings.raw !== null && hasOwnDefault2(settings.value, config)) {
+    changes.push(changeTo2(paths.piSettings, settings, withPreviousDefault2(settings.value, previousDefault)));
+  }
+  return changes;
+}
+function remove9(config, previousDefault) {
+  const changes = removal10(config, previousDefault);
+  applyChanges(config, TOOL9, changes);
+  return { path: changes[0]?.file ?? toolPaths(config).piModels, changed: changes.length > 0 };
+}
+function hasOwnEntries9(config) {
+  return removal10(config, null).length > 0;
+}
+
+// cli/src/writers/qwen-code.ts
+var qwen_code_exports = {};
+__export(qwen_code_exports, {
+  currentDefault: () => currentDefault10,
+  hasOwnEntries: () => hasOwnEntries10,
+  parseSelection: () => parseSelection,
+  remove: () => remove10,
+  selectionLabel: () => selectionLabel,
+  write: () => write10
+});
+import { mkdirSync as mkdirSync12 } from "node:fs";
+var TOOL10 = "qwen-code";
+var SETTINGS_VERSION_KEY = "$version";
+var BARE_KEYS = [SETTINGS_VERSION_KEY, "$schema"];
+var AUTH_TYPES = ["openai", "openai-responses", "qwen-oauth", "gemini", "vertex-ai", "anthropic"];
+var MODEL_PATH2 = ["model", "name"];
+var AUTH_TYPE_PATH = ["security", "auth", "selectedType"];
+var AFTER_VERSION = (keys) => keys.indexOf(SETTINGS_VERSION_KEY) + 1;
+function bucketPath(owner) {
+  return ["modelProviders", owner.provider];
+}
+function protocolPath(owner) {
+  return ["providerProtocol", owner.provider];
+}
+var KEY_PATH = ["env", API_KEY_ENV];
+function isOwnEntry2(entry, owner) {
+  const id = asObject(entry).id;
+  return typeof id === "string" && isOwnModel(id, owner);
+}
+function withOwnModels3(existing, config) {
+  const models2 = Array.isArray(existing) ? existing : [];
+  const firstOwn = models2.findIndex((entry) => isOwnEntry2(entry, config));
+  const kept = models2.filter((entry) => !isOwnEntry2(entry, config));
+  kept.splice(firstOwn === -1 ? kept.length : firstOwn, 0, ...config.models.map((model) => qwenModel(config, model)));
+  return kept;
+}
+function stringAt(settings, path) {
+  const value = valueAt(settings, path);
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function selectionIn(settings) {
+  const model = stringAt(settings, MODEL_PATH2);
+  return model === null ? null : { model, authType: stringAt(settings, AUTH_TYPE_PATH) };
+}
+function isOwnSelection(selection, owner) {
+  return selection !== null && selection.authType === QWEN_PROTOCOL && isOwnModel(selection.model, owner);
+}
+function selectionLabel(selection) {
+  return selection.authType === null ? selection.model : `${selection.model}(${selection.authType})`;
+}
+function parseSelection(value) {
+  const open = value.lastIndexOf("(");
+  if (open > 0 && value.endsWith(")")) {
+    const authType = value.slice(open + 1, -1);
+    if (AUTH_TYPES.includes(authType)) return { model: value.slice(0, open), authType };
+  }
+  return { model: value, authType: null };
+}
+function unreadable(file, command) {
+  return new Error(`${file} is not a JSON object Qwen Code can read; fix it, then run ${command} again`);
+}
+function newSettings(config, options) {
+  const settings = {
+    [SETTINGS_VERSION_KEY]: QWEN_SETTINGS_VERSION,
+    modelProviders: { [config.provider]: withOwnModels3([], config) },
+    providerProtocol: { [config.provider]: QWEN_PROTOCOL },
+    env: { [API_KEY_ENV]: config.key }
+  };
+  return options.setDefault ? { ...settings, security: { auth: { selectedType: QWEN_PROTOCOL } }, model: { name: config.model } } : settings;
+}
+function withOwnSettings(text, settings, config, options) {
+  let updated = text;
+  if (options.setDefault) {
+    updated = setJsonc(updated, MODEL_PATH2, config.model, AFTER_VERSION);
+    updated = setJsonc(updated, AUTH_TYPE_PATH, QWEN_PROTOCOL, AFTER_VERSION);
+  }
+  updated = setJsonc(updated, KEY_PATH, config.key, AFTER_VERSION);
+  updated = setJsonc(updated, protocolPath(config), QWEN_PROTOCOL, AFTER_VERSION);
+  return setJsonc(updated, bucketPath(config), withOwnModels3(valueAt(settings, bucketPath(config)), config), AFTER_VERSION);
+}
+function write10(config, options) {
+  const paths = toolPaths(config);
+  const file = paths.qwenSettings;
+  mkdirSync12(paths.qwenDir, { recursive: true });
+  const existing = readText(file);
+  const layout = layoutOf(existing ?? "");
+  const original = withoutBom(existing ?? "");
+  const settings = isBlankText(original) ? null : parseJsoncObject(original);
+  if (!isBlankText(original) && settings === null) throw unreadable(file, "the setup");
+  const updated = settings === null ? jsonText(newSettings(config, options), layout) : withBom(withOwnSettings(original, settings, config, options), layout);
+  saveText(config, TOOL10, file, updated, existing);
+  setMode(file, 384, config.platform);
+  return { path: file, next: "qwen" };
+}
+function settingsIn2(file) {
+  try {
+    if (!isFile(file)) return null;
+    const text = withoutBom(readText(file) ?? "");
+    return isBlankText(text) ? {} : parseJsoncObject(text);
+  } catch {
+    return null;
+  }
+}
+function currentDefault10(config) {
+  const settings = settingsIn2(toolPaths(config).qwenSettings);
+  const selection = settings === null ? null : selectionIn(settings);
+  if (selection === null) return null;
+  return isOwnSelection(selection, config) ? `${config.provider}/${selection.model}` : selectionLabel(selection);
+}
+function readSettingsFile2(file) {
+  if (!isFile(file)) return null;
+  const raw = readText(file) ?? "";
+  const text = withoutBom(raw);
+  const settings = isBlankText(text) ? {} : parseJsoncObject(text);
+  if (settings === null) throw unreadable(file, '"unrestricted remove"');
+  return { file, raw, text, settings };
+}
+function removeWithEmptyParents(text, path) {
+  const settings = parseJsoncObject(text) ?? {};
+  let target = [...path];
+  while (target.length > 1) {
+    const parent = valueAt(settings, target.slice(0, -1));
+    if (!isJsonObject(parent) || Object.keys(parent).length !== 1) break;
+    target = target.slice(0, -1);
+  }
+  return removeJsonc(text, target);
+}
+function withoutOwnModels2(text, settings, owner) {
+  const bucket = valueAt(settings, bucketPath(owner));
+  if (!Array.isArray(bucket)) return text;
+  const kept = bucket.filter((entry) => !isOwnEntry2(entry, owner));
+  if (kept.length === bucket.length) return text;
+  if (kept.length > 0) return setJsonc(text, bucketPath(owner), kept);
+  const updated = removeWithEmptyParents(text, bucketPath(owner));
+  return valueAt(settings, protocolPath(owner)) === void 0 ? updated : removeWithEmptyParents(updated, protocolPath(owner));
+}
+function withoutOwnKey(text, settings) {
+  const key = valueAt(settings, KEY_PATH);
+  return typeof key === "string" && key.startsWith(KEY_PREFIX) ? removeWithEmptyParents(text, KEY_PATH) : text;
+}
+function withPreviousSelection(text, previousDefault) {
+  if (previousDefault === null) return removeWithEmptyParents(removeWithEmptyParents(text, MODEL_PATH2), AUTH_TYPE_PATH);
+  const previous = parseSelection(previousDefault);
+  const updated = setJsonc(text, MODEL_PATH2, previous.model);
+  return previous.authType === null ? removeWithEmptyParents(updated, AUTH_TYPE_PATH) : setJsonc(updated, AUTH_TYPE_PATH, previous.authType);
+}
+function isBareText2(text) {
+  const settings = parseJsoncObject(text);
+  return settings !== null && Object.keys(settings).every((key) => BARE_KEYS.includes(key)) && !hasComments(text);
+}
+function removal11(config, previousDefault) {
+  const entry = readSettingsFile2(toolPaths(config).qwenSettings);
+  if (entry === null) return [];
+  let updated = withoutOwnModels2(entry.text, entry.settings, config);
+  updated = withoutOwnKey(updated, entry.settings);
+  if (isOwnSelection(selectionIn(entry.settings), config)) updated = withPreviousSelection(updated, previousDefault);
+  if (updated === entry.text) return [];
+  return [{ file: entry.file, raw: entry.raw, next: isBareText2(updated) ? null : withBom(updated, layoutOf(entry.raw)) }];
+}
+function remove10(config, previousDefault) {
+  const changes = removal11(config, previousDefault);
+  applyChanges(config, TOOL10, changes);
+  return { path: toolPaths(config).qwenSettings, changed: changes.length > 0 };
+}
+function hasOwnEntries10(config) {
+  return removal11(config, null).length > 0;
+}
 
 // cli/src/writers/index.ts
 var writers = {
-  opencode: write6,
-  codex: write3,
-  aider: write,
-  continue: write4,
-  crush: write5,
-  pi: write7,
-  claude: write2
+  opencode: opencode_exports,
+  codex: codex_exports,
+  "qwen-code": qwen_code_exports,
+  goose: goose_exports,
+  openhands: openhands_exports,
+  aider: aider_exports,
+  continue: continue_exports,
+  crush: crush_exports,
+  pi: pi_exports,
+  claude: claude_exports
 };
 
+// cli/src/commands/remove.ts
+var REMOVE_INTRO = "unrestricted.sh remove";
+var NOTHING_TO_REMOVE = "Nothing to remove.";
+function labelList(tools) {
+  const labels = tools.map((tool) => TOOL_LABELS[tool]);
+  if (labels.length === 1) return labels[0];
+  return `${labels.slice(0, -1).join(", ")} and ${labels[labels.length - 1]}`;
+}
+function removeQuestion(tools) {
+  return `Remove unrestricted.sh from ${labelList(tools)}?`;
+}
+function removedLine(tool, path) {
+  return `Removed from ${TOOL_LABELS[tool]} \xB7 ${path}`;
+}
+function nothingToRemoveLine(tool) {
+  return `${TOOL_LABELS[tool]}: nothing to remove`;
+}
+function earlierAiderLine(path) {
+  return `Your earlier Aider settings are in ${path}`;
+}
+function removeConfig(pending, state) {
+  const ids = [...state?.models ?? [], ...state?.model ? [state.model] : []];
+  return {
+    platform: pending.platform,
+    home: pending.home,
+    configHome: pending.configHome,
+    piAgentDir: pending.piAgentDir,
+    gooseConfigDir: pending.gooseConfigDir,
+    provider: pending.provider,
+    base: pending.base,
+    model: pending.model,
+    models: ids.map((id) => ({ id }))
+  };
+}
+function isSetUp(tool, config) {
+  try {
+    return writers[tool].hasOwnEntries(config) || isAutoUpdateTool(tool) && hasOwnAutoUpdateFile(tool, config);
+  } catch {
+    return false;
+  }
+}
+function namedTools(args) {
+  const tools = [];
+  for (const name of args) {
+    if (!isToolId(name)) M2.warn(`unknown tool: ${name} (skipped)`);
+    else if (!tools.includes(name)) tools.push(name);
+  }
+  return tools;
+}
+function foundTools(config, state) {
+  return ALL_TOOLS.filter((tool) => state?.tools.includes(tool) || isSetUp(tool, config));
+}
+async function confirmed(tools) {
+  if (tools.length === 0 || !process.stdin.isTTY) return true;
+  const answer = await ye({ message: removeQuestion(tools), initialValue: true });
+  return !pD(answer) && answer;
+}
+function removeFrom(tool, config, previousDefault) {
+  const result = writers[tool].remove(config, previousDefault);
+  const file = isAutoUpdateTool(tool) ? removeAutoUpdateFile(tool, config) : null;
+  return result.changed || file === null ? result : { path: file, changed: true };
+}
+function reportEarlierAider(config) {
+  const earlier = newestBackup(config, "aider", toolPaths(config).aiderConfig);
+  if (earlier !== null) M2.info(earlierAiderLine(earlier));
+}
+function forgetState(configHome, state, done) {
+  if (state === null || state.tools.every((tool) => done.includes(tool))) return deleteState(configHome);
+  forgetTools(configHome, state, done);
+  return true;
+}
+function keyLines(forgotKey, configHome, origin) {
+  const [removedKey, revoke] = logoutLines(true, credentialsPath(configHome), origin);
+  return forgotKey ? `${removedKey}
+${revoke}` : revoke;
+}
+async function remove11(context, args) {
+  let pending;
+  try {
+    pending = readConfig(context.env, context.machine);
+  } catch (error) {
+    xe(reason(error));
+    return FAILED;
+  }
+  const state = readState(pending.configHome);
+  const config = removeConfig(pending, state);
+  const everything = args.length === 0;
+  Ie(REMOVE_INTRO);
+  const tools = everything ? foundTools(config, state) : namedTools(args);
+  if (!await confirmed(tools)) {
+    xe(NOTHING_CHANGED);
+    return { code: 0 };
+  }
+  const backupsBefore = backupsMade();
+  const done = [];
+  const failed = [];
+  for (const tool of tools) {
+    try {
+      const result = removeFrom(tool, config, state?.defaults?.[tool] ?? null);
+      if (result.changed) M2.success(removedLine(tool, result.path));
+      else M2.info(nothingToRemoveLine(tool));
+      if (tool === "aider") reportEarlierAider(config);
+      done.push(tool);
+    } catch (error) {
+      failed.push(tool);
+      M2.error(`${TOOL_LABELS[tool]} failed: ${reason(error)}`);
+    }
+  }
+  if (backupsMade() > backupsBefore) M2.info(backupsLine(config));
+  let anything = tools.length > 0;
+  if (everything) {
+    const forgotState = forgetState(config.configHome, state, done);
+    const forgotKey = deleteCredentials(config.configHome);
+    anything = anything || forgotState || forgotKey;
+    if (anything) M2.info(keyLines(forgotKey, config.configHome, pending.origin));
+  } else if (state !== null) {
+    forgetTools(config.configHome, state, done);
+  }
+  Se(anything ? SETUP_OUTRO : NOTHING_TO_REMOVE);
+  return { code: failed.length > 0 ? 1 : 0 };
+}
+
 // cli/src/configure.ts
+var SWITCH_DEFAULT = { setDefault: true, kept: null };
+var KEEP_DEFAULT = { setDefault: false, kept: null };
+var START_COMMAND_TOOLS = /* @__PURE__ */ new Set(["codex", "goose"]);
+var ONE_MODEL_TOOLS = /* @__PURE__ */ new Set(["openhands"]);
+function keptDefaultMessage(current, tool, modelName) {
+  const label = TOOL_LABELS[tool];
+  if (ONE_MODEL_TOOLS.has(tool)) return `Kept ${current} in ${label}, which runs one model. Run the setup again and switch to use ${modelName}`;
+  if (START_COMMAND_TOOLS.has(tool)) return `Kept ${current} as the default in ${label}. Start it with the command under Next to use ${modelName}`;
+  return `Kept ${current} as the default in ${label}. Pick ${modelName} in its model list`;
+}
 function recordOf(result) {
   switch (result.status) {
     case "written":
@@ -3912,19 +5407,25 @@ function reportAutoUpdate(tool, result) {
   const message = autoUpdateMessage(tool, result);
   if (message !== null) M2[message.level](message.text);
 }
-function configureTools(config, tools, versionOf) {
+function reportBackups(config, before) {
+  if (backupsMade() > before) M2.info(backupsLine(config));
+}
+function configureTools(config, tools, choiceFor, versionOf) {
   const steps = [];
   const autoUpdate = {};
+  const backupsBefore = backupsMade();
   for (const tool of tools) {
     const label = TOOL_LABELS[tool];
+    const choice = choiceFor(tool);
     const step = Y2();
     step.start(`Configuring ${label}`);
     try {
-      const result = writers[tool](config);
+      const result = writers[tool].write(config, { setDefault: choice.setDefault });
       const live = isAutoUpdateTool(tool) ? { tool, result: installAutoUpdate(tool, config, versionOf) } : null;
       step.stop(`Configuring ${label}`);
       M2.success(`${label} \xB7 ${result.path}`);
       if (result.hint) M2.warn(result.hint);
+      if (choice.kept !== null) M2.info(keptDefaultMessage(choice.kept, tool, config.modelName));
       if (live !== null) {
         reportAutoUpdate(live.tool, live.result);
         const record = recordOf(live.result);
@@ -3933,13 +5434,15 @@ function configureTools(config, tools, versionOf) {
       steps.push(result.next);
     } catch (error) {
       step.stop(`${label} failed`);
+      reportBackups(config, backupsBefore);
       xe(reason(error));
       return null;
     }
   }
+  reportBackups(config, backupsBefore);
   return { steps, autoUpdate };
 }
-function rememberSetup(config, tools, autoUpdate) {
+function rememberSetup(config, tools, autoUpdate, replaced) {
   try {
     const previous = readState(config.configHome);
     saveCredentials(config.configHome, { key: config.key, origin: config.origin });
@@ -3947,7 +5450,8 @@ function rememberSetup(config, tools, autoUpdate) {
       tools: mergeTools(previous?.tools ?? [], tools),
       models: config.models.map((model) => model.id),
       model: config.model,
-      autoUpdate: mergeAutoUpdate(previous?.autoUpdate ?? {}, autoUpdate)
+      autoUpdate: mergeAutoUpdate(previous?.autoUpdate ?? {}, autoUpdate),
+      defaults: { ...previous?.defaults, ...replaced }
     });
   } catch (error) {
     M2.warn(`could not save the setup in ${storeDir(config.configHome)}: ${reason(error)}`);
@@ -3956,12 +5460,15 @@ function rememberSetup(config, tools, autoUpdate) {
 
 // cli/src/commands/setup.ts
 var SETUP_TIP = 'Tip: install the CLI with "npm i -g unrestricted", then run "unrestricted update" when new models come out.';
-async function chooseTools(context, detected) {
+function switchQuestion(tool, current, modelName) {
+  return `${TOOL_LABELS[tool]} uses ${current} by default. Switch to ${modelName}?`;
+}
+async function chooseTools(context, config, detected) {
   const requested = context.env.UNRESTRICTED_TOOLS ?? "";
   if (requested.trim()) {
     const { tools, unknown, disabled } = parseTools(requested);
     for (const name of unknown) M2.warn(`unknown tool: ${name} (skipped)`);
-    for (const tool of disabled) M2.warn(`${TOOL_LABELS[tool]} is not available yet`);
+    for (const tool of disabled) M2.warn(disabledToolMessage(tool, config.origin));
     return tools;
   }
   if (context.env.UNRESTRICTED_YES || !process.stdin.isTTY) return detected;
@@ -3977,6 +5484,31 @@ async function chooseTools(context, detected) {
   });
   return pD(answer) ? null : answer;
 }
+async function chooseDefaults(context, config, tools) {
+  const choices = {};
+  const replaced = {};
+  for (const tool of tools) {
+    const current = writers[tool].currentDefault(config);
+    if (current === null || isOwnDefault(current, config)) {
+      choices[tool] = SWITCH_DEFAULT;
+      continue;
+    }
+    if (context.env.UNRESTRICTED_YES) {
+      choices[tool] = SWITCH_DEFAULT;
+      replaced[tool] = current;
+      continue;
+    }
+    if (!process.stdin.isTTY) {
+      choices[tool] = { setDefault: false, kept: current };
+      continue;
+    }
+    const answer = await ye({ message: switchQuestion(tool, current, config.modelName), initialValue: true });
+    if (pD(answer)) return null;
+    choices[tool] = answer ? SWITCH_DEFAULT : KEEP_DEFAULT;
+    if (answer) replaced[tool] = current;
+  }
+  return { choices, replaced };
+}
 async function setup(context) {
   let pending;
   try {
@@ -4010,18 +5542,28 @@ async function setup(context) {
   check.stop(keyAcceptedMessage(pending.base));
   const config = withListedModels({ ...pending, key }, listed);
   const listedIds = config.models.map((model) => model.id);
-  const selected = await chooseTools(context, detectTools(config, context.env));
+  const selected = await chooseTools(context, config, detectTools(config, context.env));
   if (selected === null) {
-    xe("Nothing changed.");
+    xe(NOTHING_CHANGED);
     return { code: 0, listed: listedIds };
   }
   if (selected.length === 0) {
     Se("Nothing to configure.");
     return { code: 0, listed: listedIds };
   }
-  const configured = configureTools(config, selected, versionReader(context.env, context.machine.platform));
+  const defaults = await chooseDefaults(context, config, selected);
+  if (defaults === null) {
+    xe(NOTHING_CHANGED);
+    return { code: 0, listed: listedIds };
+  }
+  const configured = configureTools(
+    config,
+    selected,
+    (tool) => defaults.choices[tool] ?? SWITCH_DEFAULT,
+    versionReader(context.env, context.machine.platform)
+  );
   if (configured === null) return FAILED;
-  rememberSetup(config, selected, configured.autoUpdate);
+  rememberSetup(config, selected, configured.autoUpdate, defaults.replaced);
   if (balanceNote) M2.info(balanceNote);
   Me(configured.steps.join("\n"), "Next");
   if (!context.installed) M2.info(SETUP_TIP);
@@ -4033,6 +5575,10 @@ async function setup(context) {
 var UPDATE_INTRO = "unrestricted.sh update";
 var NO_TOOLS_MESSAGE = 'No tools are set up yet. Run "unrestricted setup" to configure them.';
 var NO_KEY_MESSAGE2 = 'No key is stored. Run "unrestricted setup" to sign in and configure your tools.';
+var AIDER_NOT_UPDATED = 'Aider is no longer updated. Run "unrestricted remove aider" to take it out';
+function skippedToolMessage(tool) {
+  return tool === "aider" ? AIDER_NOT_UPDATED : `${TOOL_LABELS[tool]} is not available yet`;
+}
 function selectedModel(env, pending, state, listed) {
   if (env.UNRESTRICTED_MODEL || state.model === null) return pending.model;
   return listed.some((model) => model.id === state.model) ? state.model : pending.model;
@@ -4068,11 +5614,11 @@ async function update(context) {
   }
   check.stop(keyAcceptedMessage(pending.base));
   const config = withListedModels({ ...pending, key, model: selectedModel(context.env, pending, state, listed) }, listed);
-  for (const tool of state.tools.filter((tool2) => DISABLED_TOOLS.has(tool2))) M2.warn(`${TOOL_LABELS[tool]} is not available yet`);
+  for (const tool of state.tools.filter((tool2) => DISABLED_TOOLS.has(tool2))) M2.warn(skippedToolMessage(tool));
   const tools = state.tools.filter((tool) => !DISABLED_TOOLS.has(tool));
-  const configured = configureTools(config, tools, versionReader(context.env, context.machine.platform));
+  const configured = configureTools(config, tools, () => KEEP_DEFAULT, versionReader(context.env, context.machine.platform));
   if (configured === null) return FAILED;
-  rememberSetup(config, tools, configured.autoUpdate);
+  rememberSetup(config, tools, configured.autoUpdate, {});
   const added = config.models.filter((model) => !state.models.includes(model.id));
   if (added.length > 0) M2.info(`New: ${added.map((model) => model.name).join(", ")}`);
   Se(SETUP_OUTRO);
@@ -4111,14 +5657,15 @@ async function announceNewModels(context, listed) {
 }
 
 // cli/package.json
-var version = "1.0.0";
+var version = "1.1.0";
 
 // cli/src/version.ts
 var VERSION = version;
 
 // cli/src/cli.ts
-var COMMAND_NAMES = ["setup", "update", "models", "balance", "login", "logout"];
-var COMMANDS = { setup, update, models, balance, login, logout };
+var COMMAND_NAMES = ["setup", "update", "remove", "models", "balance", "login", "logout"];
+var COMMANDS = { setup, update, remove: remove11, models, balance, login, logout };
+var TAKES_ARGUMENTS = /* @__PURE__ */ new Set(["remove"]);
 var HELP_FLAGS = ["-h", "--help"];
 var VERSION_FLAGS = ["-v", "--version"];
 var HELP_HINT = 'Run "unrestricted --help" for the commands.';
@@ -4136,6 +5683,7 @@ function helpText() {
     "Commands:",
     "  setup     Configure your coding tools (the default)",
     "  update    Rewrite the tools you set up with the current models and your stored key",
+    "  remove    Take unrestricted.sh out of your coding tools",
     "  models    List the models with their context and prices per million tokens",
     "  balance   Show your credit, your plan's usage and this month's spend",
     "  login     Approve this machine in the browser and store its key",
@@ -4172,10 +5720,10 @@ function parseArguments(argv) {
   if (argv.some((argument) => VERSION_FLAGS.includes(argument))) return { kind: "version" };
   const option = argv.find((argument) => argument.startsWith("-"));
   if (option !== void 0) return { kind: "error", message: `unknown option: ${option}. ${HELP_HINT}` };
-  const [name = "setup", extra] = argv;
+  const [name = "setup", ...args] = argv;
   if (!isCommandName(name)) return { kind: "error", message: `unknown command: ${name}. ${HELP_HINT}` };
-  if (extra !== void 0) return { kind: "error", message: `unexpected argument: ${extra}. ${HELP_HINT}` };
-  return { kind: "command", name };
+  if (args.length > 0 && !TAKES_ARGUMENTS.has(name)) return { kind: "error", message: `unexpected argument: ${args[0]}. ${HELP_HINT}` };
+  return { kind: "command", name, args };
 }
 async function runCli(argv, context) {
   const parsed = parseArguments(argv);
@@ -4193,7 +5741,7 @@ async function runCli(argv, context) {
 `);
     return 1;
   }
-  const result = await COMMANDS[parsed.name](context);
+  const result = await COMMANDS[parsed.name](context, parsed.args);
   if (result.code === 0 && parsed.name !== "logout") await announceNewModels(context, result.listed);
   return result.code;
 }