zenox 1.0.0 → 1.0.2

package/README.md

@@ -9,7 +9,7 @@ OpenCode plugin for intelligent agent orchestration with specialized subagents a
 - **Auto-Update**: Automatic update checking with toast notifications
 - **Auto-Loaded MCP Servers**: exa, grep_app, sequential-thinking
 - **Smart Orchestration**: Automatically teaches Build/Plan agents how to delegate
-- **CLI Installer**: Easy setup via `bunx zenox install`
+- **CLI Installer**: Easy setup with model configuration via `bunx zenox install`
 
 ## Installation
 
@@ -22,7 +22,8 @@ bunx zenox install
 This will:
 - Create `opencode.json` if it doesn't exist
 - Add zenox to your plugins array
-- Preserve existing configuration
+- Let you configure custom models for each agent (optional)
+- Detect models from your existing opencode.json config
 
 ### Manual Install
 
@@ -34,19 +35,23 @@ Add to your `opencode.json`:
 }
 ```
 
-> **Note**: Don't pin the version (e.g., `zenox@0.1.0`) if you want automatic updates.
+> **Note**: Don't pin the version (e.g., `zenox@1.0.0`) if you want automatic updates.
 
 Restart OpenCode and the plugin is ready to use.
 
 ## CLI Commands
 
 ```bash
-# Interactive install with TUI
+# Interactive install with model configuration
 bunx zenox install
 
-# Non-interactive mode (CI/scripts)
+# Non-interactive mode (uses default models)
 bunx zenox install --no-tui
 
+# Reconfigure agent models later
+bunx zenox config
+bunx zenox models  # alias
+
 # Specify config path
 bunx zenox install --config ./path/to/opencode.json
 
@@ -54,6 +59,18 @@ bunx zenox install --config ./path/to/opencode.json
 bunx zenox --help
 ```
 
+### Model Configuration
+
+During installation, you can choose to customize models for each agent:
+
+1. **Use recommended defaults** - No config file needed
+2. **Customize models** - Pick from:
+   - Recommended default model
+   - Models defined in your opencode.json
+   - Enter a custom model name (see [models.dev](https://models.dev))
+
+Custom models are saved to `~/.config/opencode/zenox.json`.
+
 ## Agents
 
 ### @explorer
@@ -62,7 +79,7 @@ Fast codebase search specialist.
 - "Find all files containing Y"
 - Pattern matching and locating implementations
 
-**Model**: `anthropic/claude-haiku-4-5`
+**Default Model**: `anthropic/claude-haiku-4-5`
 
 ### @librarian
 Open-source research agent.
@@ -70,7 +87,7 @@ Open-source research agent.
 - "Show me implementation examples"
 - Finding official documentation
 
-**Model**: `anthropic/claude-sonnet-4-5`
+**Default Model**: `anthropic/claude-sonnet-4-5`
 
 ### @oracle
 Strategic technical advisor.
@@ -78,7 +95,7 @@ Strategic technical advisor.
 - Code review and debugging strategy
 - Technical trade-offs analysis
 
-**Model**: `openai/gpt-5.2-high`
+**Default Model**: `openai/gpt-5.2`
 
 ### @ui-planner
 Designer-turned-developer.
@@ -86,7 +103,7 @@ Designer-turned-developer.
 - Frontend aesthetics and animations
 - Visual design without mockups
 
-**Model**: `google/gemini-3-pro-high`
+**Default Model**: `google/gemini-3-pro-high`
 
 ## Background Tasks
 
@@ -122,11 +139,21 @@ Zenox automatically checks for updates on startup:
 3. **Cache Invalidation**: If update available, clears Bun cache
 4. **Update Toast**: Notifies you to restart OpenCode
 
-To disable auto-updates, pin your version: `"zenox@0.1.0"`
+To disable auto-updates, pin your version: `"zenox@1.0.0"`
+
+## Configuration
+
+### Via CLI (Recommended)
+
+```bash
+bunx zenox config
+```
+
+Interactive UI to select models for each agent.
 
-## Configuration (Optional)
+### Manual Configuration
 
-Create `~/.config/opencode/zenox.json` or `.opencode/zenox.json`:
+Create `~/.config/opencode/zenox.json`:
 
 ```json
 {

package/dist/cli/config.d.ts

@@ -0,0 +1 @@
+export declare function runConfig(): Promise<void>;

package/dist/cli/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const PACKAGE_NAME = "zenox";
+export type AgentName = "explorer" | "librarian" | "oracle" | "ui-planner";
+export interface AgentInfo {
+    name: AgentName;
+    displayName: string;
+    defaultModel: string;
+    description: string;
+}
+export declare const AGENTS: AgentInfo[];
+export declare const DEFAULT_MODELS: Record<AgentName, string>;

package/dist/cli/index.js

@@ -2258,6 +2258,7 @@ var {
 
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
+var import_picocolors = __toESM(require_picocolors(), 1);
 import { stdin as j, stdout as M } from "node:process";
 import * as g from "node:readline";
 import O from "node:readline";
@@ -2632,9 +2633,89 @@ class dD extends x {
 }
 var A;
 A = new WeakMap;
+var kD = Object.defineProperty;
+var $D = (e, u, t) => (u in e) ? kD(e, u, { enumerable: true, configurable: true, writable: true, value: t }) : e[u] = t;
+var H = (e, u, t) => ($D(e, typeof u != "symbol" ? u + "" : u, t), t);
+var SD = class extends x {
+  constructor(u) {
+    super(u, false), H(this, "options"), H(this, "cursor", 0), this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: t }) => t === u.cursorAt), 0), this.on("key", (t) => {
+      t === "a" && this.toggleAll();
+    }), this.on("cursor", (t) => {
+      switch (t) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  toggleAll() {
+    const u = this.value.length === this.options.length;
+    this.value = u ? [] : this.options.map((t) => t.value);
+  }
+  toggleValue() {
+    const u = this.value.includes(this._value);
+    this.value = u ? this.value.filter((t) => t !== this._value) : [...this.value, this._value];
+  }
+};
+var OD = Object.defineProperty;
+var PD = (e, u, t) => (u in e) ? OD(e, u, { enumerable: true, configurable: true, writable: true, value: t }) : e[u] = t;
+var J = (e, u, t) => (PD(e, typeof u != "symbol" ? u + "" : u, t), t);
+
+class LD extends x {
+  constructor(u) {
+    super(u, false), J(this, "options"), J(this, "cursor", 0), this.options = u.options, this.cursor = this.options.findIndex(({ value: t }) => t === u.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (t) => {
+      switch (t) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+      }
+      this.changeValue();
+    });
+  }
+  get _value() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._value.value;
+  }
+}
+class RD extends x {
+  get valueWithCursor() {
+    if (this.state === "submit")
+      return this.value;
+    if (this.cursor >= this.value.length)
+      return `${this.value}█`;
+    const u = this.value.slice(0, this.cursor), [t, ...F] = this.value.slice(this.cursor);
+    return `${u}${import_picocolors.default.inverse(t)}${F.join("")}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(u) {
+    super(u), this.on("finalize", () => {
+      this.value || (this.value = u.defaultValue);
+    });
+  }
+}
 
 // node_modules/@clack/prompts/dist/index.mjs
-var import_picocolors = __toESM(require_picocolors(), 1);
+var import_picocolors2 = __toESM(require_picocolors(), 1);
 var import_sisteransi2 = __toESM(require_src(), 1);
 import y2 from "node:process";
 function ce() {
@@ -2667,83 +2748,187 @@ var b2 = (t) => {
   switch (t) {
     case "initial":
     case "active":
-      return import_picocolors.default.cyan(le);
+      return import_picocolors2.default.cyan(le);
     case "cancel":
-      return import_picocolors.default.red(L2);
+      return import_picocolors2.default.red(L2);
     case "error":
-      return import_picocolors.default.yellow(W2);
+      return import_picocolors2.default.yellow(W2);
     case "submit":
-      return import_picocolors.default.green(C);
+      return import_picocolors2.default.green(C);
   }
 };
+var G2 = (t) => {
+  const { cursor: n, options: r2, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5));
+  let l2 = 0;
+  n >= l2 + a - 3 ? l2 = Math.max(Math.min(n - a + 3, r2.length - a), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
+  const $2 = a < r2.length && l2 > 0, g2 = a < r2.length && l2 + a < r2.length;
+  return r2.slice(l2, l2 + a).map((p2, v2, f) => {
+    const j2 = v2 === 0 && $2, E = v2 === f.length - 1 && g2;
+    return j2 || E ? import_picocolors2.default.dim("...") : i(p2, v2 + l2 === n);
+  });
+};
+var he = (t) => new RD({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, render() {
+  const n = `${import_picocolors2.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`, r2 = t.placeholder ? import_picocolors2.default.inverse(t.placeholder[0]) + import_picocolors2.default.dim(t.placeholder.slice(1)) : import_picocolors2.default.inverse(import_picocolors2.default.hidden("_")), i = this.value ? this.valueWithCursor : r2;
+  switch (this.state) {
+    case "error":
+      return `${n.trim()}
+${import_picocolors2.default.yellow(o)}  ${i}
+${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(this.error)}
+`;
+    case "submit":
+      return `${n}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(this.value || t.placeholder)}`;
+    case "cancel":
+      return `${n}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(this.value ?? ""))}${this.value?.trim() ? `
+${import_picocolors2.default.gray(o)}` : ""}`;
+    default:
+      return `${n}${import_picocolors2.default.cyan(o)}  ${i}
+${import_picocolors2.default.cyan(d2)}
+`;
+  }
+} }).prompt();
 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)}
+    const i = `${import_picocolors2.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)}`;
+        return `${i}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(s)}`;
+      case "cancel":
+        return `${i}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}
+${import_picocolors2.default.gray(o)}`;
+      default:
+        return `${i}${import_picocolors2.default.cyan(o)}  ${this.value ? `${import_picocolors2.default.green(k2)} ${n}` : `${import_picocolors2.default.dim(P2)} ${import_picocolors2.default.dim(n)}`} ${import_picocolors2.default.dim("/")} ${this.value ? `${import_picocolors2.default.dim(P2)} ${import_picocolors2.default.dim(r2)}` : `${import_picocolors2.default.green(k2)} ${r2}`}
+${import_picocolors2.default.cyan(d2)}
+`;
+    }
+  } }).prompt();
+};
+var ve = (t) => {
+  const n = (r2, i) => {
+    const s = r2.label ?? String(r2.value);
+    switch (i) {
+      case "selected":
+        return `${import_picocolors2.default.dim(s)}`;
+      case "active":
+        return `${import_picocolors2.default.green(k2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}`;
+      case "cancelled":
+        return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}`;
+      default:
+        return `${import_picocolors2.default.dim(P2)} ${import_picocolors2.default.dim(s)}`;
+    }
+  };
+  return new LD({ options: t.options, initialValue: t.initialValue, render() {
+    const r2 = `${import_picocolors2.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`;
+    switch (this.state) {
+      case "submit":
+        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${i}${import_picocolors.default.gray(o)}  ${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}
-${import_picocolors.default.gray(o)}`;
+        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors2.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)}
+        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
+${import_picocolors2.default.cyan(o)}  `)}
+${import_picocolors2.default.cyan(d2)}
+`;
+    }
+  } }).prompt();
+};
+var fe = (t) => {
+  const n = (r2, i) => {
+    const s = r2.label ?? String(r2.value);
+    return i === "active" ? `${import_picocolors2.default.cyan(A2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "selected" ? `${import_picocolors2.default.green(T)} ${import_picocolors2.default.dim(s)} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : i === "active-selected" ? `${import_picocolors2.default.green(T)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}` : i === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(F)} ${import_picocolors2.default.dim(s)}`;
+  };
+  return new SD({ options: t.options, initialValues: t.initialValues, required: t.required ?? true, cursorAt: t.cursorAt, validate(r2) {
+    if (this.required && r2.length === 0)
+      return `Please select at least one option.
+${import_picocolors2.default.reset(import_picocolors2.default.dim(`Press ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" space ")))} to select, ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" enter ")))} to submit`))}`;
+  }, render() {
+    const r2 = `${import_picocolors2.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`, i = (s, c) => {
+      const a = this.value.includes(s.value);
+      return c && a ? n(s, "active-selected") : a ? n(s, "selected") : n(s, c ? "active" : "inactive");
+    };
+    switch (this.state) {
+      case "submit":
+        return `${r2}${import_picocolors2.default.gray(o)}  ${this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
+      case "cancel": {
+        const s = this.options.filter(({ value: c }) => this.value.includes(c)).map((c) => n(c, "cancelled")).join(import_picocolors2.default.dim(", "));
+        return `${r2}${import_picocolors2.default.gray(o)}  ${s.trim() ? `${s}
+${import_picocolors2.default.gray(o)}` : ""}`;
+      }
+      case "error": {
+        const s = this.error.split(`
+`).map((c, a) => a === 0 ? `${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(c)}` : `   ${c}`).join(`
+`);
+        return `${r2 + import_picocolors2.default.yellow(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+${import_picocolors2.default.yellow(o)}  `)}
+${s}
+`;
+      }
+      default:
+        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ options: this.options, cursor: this.cursor, maxItems: t.maxItems, style: i }).join(`
+${import_picocolors2.default.cyan(o)}  `)}
+${import_picocolors2.default.cyan(d2)}
 `;
     }
   } }).prompt();
 };
 var xe = (t = "") => {
-  process.stdout.write(`${import_picocolors.default.gray(d2)}  ${import_picocolors.default.red(t)}
+  process.stdout.write(`${import_picocolors2.default.gray(d2)}  ${import_picocolors2.default.red(t)}
 
 `);
 };
 var Ie = (t = "") => {
-  process.stdout.write(`${import_picocolors.default.gray(ue)}  ${t}
+  process.stdout.write(`${import_picocolors2.default.gray(ue)}  ${t}
 `);
 };
 var Se = (t = "") => {
-  process.stdout.write(`${import_picocolors.default.gray(o)}
-${import_picocolors.default.gray(d2)}  ${t}
+  process.stdout.write(`${import_picocolors2.default.gray(o)}
+${import_picocolors2.default.gray(d2)}  ${t}
 
 `);
 };
-var M2 = { message: (t = "", { symbol: n = import_picocolors.default.gray(o) } = {}) => {
-  const r2 = [`${import_picocolors.default.gray(o)}`];
+var M2 = { message: (t = "", { symbol: n = import_picocolors2.default.gray(o) } = {}) => {
+  const r2 = [`${import_picocolors2.default.gray(o)}`];
   if (t) {
     const [i, ...s] = t.split(`
 `);
-    r2.push(`${n}  ${i}`, ...s.map((c) => `${import_picocolors.default.gray(o)}  ${c}`));
+    r2.push(`${n}  ${i}`, ...s.map((c) => `${import_picocolors2.default.gray(o)}  ${c}`));
   }
   process.stdout.write(`${r2.join(`
 `)}
 `);
 }, info: (t) => {
-  M2.message(t, { symbol: import_picocolors.default.blue(q) });
+  M2.message(t, { symbol: import_picocolors2.default.blue(q) });
 }, success: (t) => {
-  M2.message(t, { symbol: import_picocolors.default.green(D) });
+  M2.message(t, { symbol: import_picocolors2.default.green(D) });
 }, step: (t) => {
-  M2.message(t, { symbol: import_picocolors.default.green(C) });
+  M2.message(t, { symbol: import_picocolors2.default.green(C) });
 }, warn: (t) => {
-  M2.message(t, { symbol: import_picocolors.default.yellow(U) });
+  M2.message(t, { symbol: import_picocolors2.default.yellow(U) });
 }, warning: (t) => {
   M2.warn(t);
 }, error: (t) => {
-  M2.message(t, { symbol: import_picocolors.default.red(K2) });
+  M2.message(t, { symbol: import_picocolors2.default.red(K2) });
 } };
-var J = `${import_picocolors.default.gray(o)}  `;
+var J2 = `${import_picocolors2.default.gray(o)}  `;
 var Y2 = ({ indicator: t = "dots" } = {}) => {
   const n = V2 ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"], r2 = V2 ? 80 : 120, i = process.env.CI === "true";
   let s, c, a = false, l2 = "", $2, g2 = performance.now();
   const p2 = (m2) => {
     const h2 = m2 > 1 ? "Something went wrong" : "Canceled";
     a && N2(h2, m2);
-  }, v = () => p2(2), f = () => p2(1), j2 = () => {
-    process.on("uncaughtExceptionMonitor", v), process.on("unhandledRejection", v), process.on("SIGINT", f), process.on("SIGTERM", f), process.on("exit", p2);
+  }, v2 = () => p2(2), f = () => p2(1), j2 = () => {
+    process.on("uncaughtExceptionMonitor", v2), process.on("unhandledRejection", v2), process.on("SIGINT", f), process.on("SIGTERM", f), process.on("exit", p2);
   }, E = () => {
-    process.removeListener("uncaughtExceptionMonitor", v), process.removeListener("unhandledRejection", v), process.removeListener("SIGINT", f), process.removeListener("SIGTERM", f), process.removeListener("exit", p2);
+    process.removeListener("uncaughtExceptionMonitor", v2), process.removeListener("unhandledRejection", v2), process.removeListener("SIGINT", f), process.removeListener("SIGTERM", f), process.removeListener("exit", p2);
   }, B2 = () => {
     if ($2 === undefined)
       return;
@@ -2755,15 +2940,15 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
   }, R2 = (m2) => m2.replace(/\.+$/, ""), O2 = (m2) => {
     const h2 = (performance.now() - m2) / 1000, w2 = Math.floor(h2 / 60), I2 = Math.floor(h2 % 60);
     return w2 > 0 ? `[${w2}m ${I2}s]` : `[${I2}s]`;
-  }, H = (m2 = "") => {
-    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors.default.gray(o)}
+  }, H2 = (m2 = "") => {
+    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors2.default.gray(o)}
 `);
     let h2 = 0, w2 = 0;
     j2(), c = setInterval(() => {
       if (i && l2 === $2)
         return;
       B2(), $2 = l2;
-      const I2 = import_picocolors.default.magenta(n[h2]);
+      const I2 = import_picocolors2.default.magenta(n[h2]);
       if (i)
         process.stdout.write(`${I2}  ${l2}...`);
       else if (t === "timer")
@@ -2776,24 +2961,152 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     }, r2);
   }, N2 = (m2 = "", h2 = 0) => {
     a = false, clearInterval(c), B2();
-    const w2 = h2 === 0 ? import_picocolors.default.green(C) : h2 === 1 ? import_picocolors.default.red(L2) : import_picocolors.default.red(W2);
+    const w2 = h2 === 0 ? import_picocolors2.default.green(C) : h2 === 1 ? import_picocolors2.default.red(L2) : import_picocolors2.default.red(W2);
     l2 = R2(m2 ?? l2), t === "timer" ? process.stdout.write(`${w2}  ${l2} ${O2(g2)}
 `) : process.stdout.write(`${w2}  ${l2}
 `), E(), s();
   };
-  return { start: H, stop: N2, message: (m2 = "") => {
+  return { start: H2, stop: N2, message: (m2 = "") => {
     l2 = R2(m2 ?? l2);
   } };
 };
 
 // src/cli/install.ts
-var import_picocolors2 = __toESM(require_picocolors(), 1);
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 
 // src/cli/config-manager.ts
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+
+// node_modules/strip-json-comments/index.js
+var singleComment = Symbol("singleComment");
+var multiComment = Symbol("multiComment");
+var stripWithoutWhitespace = () => "";
+var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/[^ \t\r\n]/g, " ");
+var isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0;index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === `\r
+`) {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (isInsideComment === singleComment && currentCharacter === `
+`) {
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+      continue;
+    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "\t" && currentCharacter !== "\r" && currentCharacter !== `
+`) {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
+    }
+  }
+  const remaining = isInsideComment === singleComment ? strip(jsonString, offset) : jsonString.slice(offset);
+  return result + buffer + remaining;
+}
+
+// src/cli/constants.ts
 var PACKAGE_NAME = "zenox";
+var AGENTS = [
+  {
+    name: "explorer",
+    displayName: "Explorer",
+    defaultModel: "anthropic/claude-haiku-4-5",
+    description: "Fast codebase search specialist"
+  },
+  {
+    name: "librarian",
+    displayName: "Librarian",
+    defaultModel: "anthropic/claude-sonnet-4-5",
+    description: "Open-source research agent"
+  },
+  {
+    name: "oracle",
+    displayName: "Oracle",
+    defaultModel: "openai/gpt-5.2",
+    description: "Strategic technical advisor"
+  },
+  {
+    name: "ui-planner",
+    displayName: "UI-Planner",
+    defaultModel: "google/gemini-3-pro-high",
+    description: "Designer-turned-developer"
+  }
+];
+var DEFAULT_MODELS = {
+  explorer: "anthropic/claude-haiku-4-5",
+  librarian: "anthropic/claude-sonnet-4-5",
+  oracle: "openai/gpt-5.2",
+  "ui-planner": "google/gemini-3-pro-high"
+};
+
+// src/cli/config-manager.ts
 var CONFIG_FILENAMES = ["opencode.json", "opencode.jsonc"];
 function findConfigFile(directory) {
   for (const filename of CONFIG_FILENAMES) {
@@ -2807,16 +3120,16 @@ function findConfigFile(directory) {
 }
 async function readConfig(configPath) {
   const content = await readFile(configPath, "utf-8");
-  const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const jsonContent = stripJsonComments(content, { trailingCommas: true });
   const config = JSON.parse(jsonContent);
   return { content, config };
 }
 function isPluginInstalled(config) {
-  const plugins = config.plugins ?? [];
+  const plugins = config.plugins ?? config.plugin ?? [];
   return plugins.some((p2) => p2 === PACKAGE_NAME || p2.startsWith(`${PACKAGE_NAME}@`));
 }
 function addPluginToJsonc(content) {
-  const pluginsMatch = content.match(/"plugins"\s*:\s*\[/);
+  const pluginsMatch = content.match(/"plugins"\s*:\s*\[/) ?? content.match(/"plugin"\s*:\s*\[/);
   if (pluginsMatch) {
     const insertIndex = content.indexOf("[", pluginsMatch.index) + 1;
     const beforeBracket = content.slice(0, insertIndex);
@@ -2841,14 +3154,17 @@ function addPluginToJsonc(content) {
 }`;
     } else {
       return `${beforeBrace}
-  "plugins": ["${PACKAGE_NAME}"],${afterBrace}`;
+  "plugins": ["${PACKAGE_NAME}"],
+  ${afterBrace.trimStart()}`;
     }
   }
 }
 function addPluginToJson(config) {
+  const existingKey = config.plugins ? "plugins" : config.plugin ? "plugin" : "plugins";
+  const existingPlugins = config.plugins ?? config.plugin ?? [];
   const newConfig = {
-    plugins: [PACKAGE_NAME, ...config.plugins ?? []],
-    ...Object.fromEntries(Object.entries(config).filter(([key]) => key !== "plugins"))
+    [existingKey]: [PACKAGE_NAME, ...existingPlugins],
+    ...Object.fromEntries(Object.entries(config).filter(([key]) => key !== "plugins" && key !== "plugin"))
   };
   return JSON.stringify(newConfig, null, 2) + `
 `;
@@ -2873,8 +3189,189 @@ async function createDefaultConfig(configPath) {
 `, "utf-8");
 }
 
+// src/cli/zenox-config.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile2, writeFile as writeFile2, mkdir } from "node:fs/promises";
+import { join as join2, dirname } from "node:path";
+import { homedir } from "node:os";
+function getZenoxConfigPath() {
+  return join2(homedir(), ".config", "opencode", "zenox.json");
+}
+async function readZenoxConfig() {
+  const configPath = getZenoxConfigPath();
+  if (!existsSync2(configPath))
+    return null;
+  try {
+    const content = await readFile2(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeZenoxConfig(config) {
+  const configPath = getZenoxConfigPath();
+  const configDir = dirname(configPath);
+  if (!existsSync2(configDir)) {
+    await mkdir(configDir, { recursive: true });
+  }
+  await writeFile2(configPath, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+async function updateAgentModels(models) {
+  const existing = await readZenoxConfig() ?? {};
+  const agents = { ...existing.agents };
+  for (const [agent, model] of Object.entries(models)) {
+    if (model) {
+      agents[agent] = { model };
+    }
+  }
+  await writeZenoxConfig({
+    ...existing,
+    agents
+  });
+}
+function getCurrentModels(config) {
+  if (!config?.agents)
+    return {};
+  const result = {};
+  for (const [agent, settings] of Object.entries(config.agents)) {
+    if (settings?.model) {
+      result[agent] = settings.model;
+    }
+  }
+  return result;
+}
+
+// src/cli/model-picker.ts
+var CUSTOM_MODEL_OPTION = "__custom__";
+function extractUserModels(config) {
+  const models = new Set;
+  const provider = config.provider;
+  if (!provider)
+    return [];
+  for (const providerConfig of Object.values(provider)) {
+    if (typeof providerConfig !== "object" || providerConfig === null)
+      continue;
+    const providerModels = providerConfig.models;
+    if (typeof providerModels !== "object" || providerModels === null)
+      continue;
+    for (const modelId of Object.keys(providerModels)) {
+      models.add(modelId);
+    }
+  }
+  return Array.from(models).sort();
+}
+function buildModelOptions(agent, userModels, currentModel) {
+  const options = [];
+  const isDefault = !currentModel || currentModel === agent.defaultModel;
+  options.push({
+    value: agent.defaultModel,
+    label: `${agent.defaultModel}${isDefault ? " (Current)" : ""}`,
+    hint: "Recommended - Default"
+  });
+  for (const model of userModels) {
+    if (model === agent.defaultModel)
+      continue;
+    const isCurrent = currentModel === model;
+    options.push({
+      value: model,
+      label: `${model}${isCurrent ? " (Current)" : ""}`,
+      hint: "From your config"
+    });
+  }
+  if (currentModel && currentModel !== agent.defaultModel && !userModels.includes(currentModel)) {
+    options.push({
+      value: currentModel,
+      label: `${currentModel} (Current)`,
+      hint: "Custom"
+    });
+  }
+  options.push({
+    value: CUSTOM_MODEL_OPTION,
+    label: "Enter custom model name",
+    hint: "Get names from models.dev"
+  });
+  return options;
+}
+async function pickModelForAgent(agent, userModels, currentModel) {
+  const options = buildModelOptions(agent, userModels, currentModel);
+  const selected = await ve({
+    message: `${agent.displayName} agent model:`,
+    options
+  });
+  if (pD(selected))
+    return null;
+  if (selected === CUSTOM_MODEL_OPTION) {
+    const customModel = await he({
+      message: "Enter custom model name:",
+      placeholder: "e.g., anthropic/claude-sonnet-4 (see models.dev)",
+      validate: (value) => {
+        if (!value.trim())
+          return "Model name is required";
+        if (!value.includes("/"))
+          return "Model should be in format: provider/model-name";
+        return;
+      }
+    });
+    if (pD(customModel))
+      return null;
+    return customModel;
+  }
+  return selected;
+}
+async function pickModelsForAllAgents(userModels, currentModels) {
+  const result = {};
+  for (const agent of AGENTS) {
+    const current = currentModels[agent.name];
+    const model = await pickModelForAgent(agent, userModels, current);
+    if (model === null)
+      return null;
+    if (model !== agent.defaultModel) {
+      result[agent.name] = model;
+    }
+  }
+  return result;
+}
+async function askConfigureModels() {
+  const result = await ve({
+    message: "Configure sub-agent models?",
+    options: [
+      {
+        value: "defaults",
+        label: "Use recommended defaults",
+        hint: "No config file needed"
+      },
+      {
+        value: "customize",
+        label: "Customize models",
+        hint: "Choose models for each agent"
+      }
+    ]
+  });
+  if (pD(result))
+    return null;
+  return result;
+}
+async function selectAgentsToReconfigure(currentModels) {
+  const options = AGENTS.map((agent) => {
+    const current = currentModels[agent.name] ?? agent.defaultModel;
+    return {
+      value: agent.name,
+      label: agent.displayName,
+      hint: `current: ${current}`
+    };
+  });
+  const selected = await fe({
+    message: "Which agents to configure?",
+    options,
+    required: true
+  });
+  if (pD(selected))
+    return null;
+  return selected;
+}
+
 // src/cli/install.ts
-var PACKAGE_NAME2 = "zenox";
 async function runInstall(options = {}) {
   const { noTui = false, configPath: customConfigPath } = options;
   const cwd = process.cwd();
@@ -2885,8 +3382,9 @@ async function runInstall(options = {}) {
   await runInteractive(cwd, customConfigPath);
 }
 async function runInteractive(cwd, customConfigPath) {
-  Ie(import_picocolors2.default.cyan(`${PACKAGE_NAME2} installer`));
+  Ie(import_picocolors3.default.cyan(`${PACKAGE_NAME} installer`));
   const configFile = customConfigPath ? { path: customConfigPath, format: "json" } : findConfigFile(cwd);
+  let opencodeConfig = null;
   if (!configFile) {
     const shouldCreate = await ye({
       message: "No opencode.json found. Create one?",
@@ -2897,73 +3395,178 @@ async function runInteractive(cwd, customConfigPath) {
       process.exit(0);
     }
     const configPath = getDefaultConfigPath(cwd);
-    const spinner2 = Y2();
-    spinner2.start("Creating opencode.json");
+    const spinner = Y2();
+    spinner.start("Creating opencode.json");
     try {
       await createDefaultConfig(configPath);
-      spinner2.stop("Created opencode.json");
-      Se(import_picocolors2.default.green(`${PACKAGE_NAME2} installed successfully!`));
+      spinner.stop("Created opencode.json");
     } catch (err) {
-      spinner2.stop("Failed to create config");
+      spinner.stop("Failed to create config");
       M2.error(err instanceof Error ? err.message : "Unknown error");
       process.exit(1);
     }
-    return;
-  }
-  try {
-    const { config } = await readConfig(configFile.path);
-    if (isPluginInstalled(config)) {
-      M2.warn(`${PACKAGE_NAME2} is already installed in ${configFile.path}`);
-      Se(import_picocolors2.default.yellow("No changes made"));
-      return;
+  } else {
+    try {
+      const result = await readConfig(configFile.path);
+      opencodeConfig = result.config;
+      if (isPluginInstalled(opencodeConfig)) {
+        M2.info(`${PACKAGE_NAME} is already in ${configFile.path}`);
+      } else {
+        const shouldInstall = await ye({
+          message: `Add ${PACKAGE_NAME} to ${configFile.path}?`,
+          initialValue: true
+        });
+        if (pD(shouldInstall) || !shouldInstall) {
+          xe("Installation cancelled");
+          process.exit(0);
+        }
+        const spinner = Y2();
+        spinner.start(`Adding ${PACKAGE_NAME} to plugins`);
+        try {
+          await installPlugin(configFile.path);
+          spinner.stop(`Added ${PACKAGE_NAME} to plugins`);
+        } catch (err) {
+          spinner.stop("Failed to install");
+          M2.error(err instanceof Error ? err.message : "Unknown error");
+          process.exit(1);
+        }
+      }
+    } catch (err) {
+      M2.error(`Failed to read config: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
     }
-  } catch (err) {
-    M2.error(`Failed to read config: ${err instanceof Error ? err.message : "Unknown error"}`);
-    process.exit(1);
   }
-  const shouldInstall = await ye({
-    message: `Add ${PACKAGE_NAME2} to ${configFile.path}?`,
-    initialValue: true
-  });
-  if (pD(shouldInstall) || !shouldInstall) {
+  const configureChoice = await askConfigureModels();
+  if (configureChoice === null) {
     xe("Installation cancelled");
     process.exit(0);
   }
-  const spinner = Y2();
-  spinner.start(`Adding ${PACKAGE_NAME2} to plugins`);
-  try {
-    await installPlugin(configFile.path);
-    spinner.stop(`Added ${PACKAGE_NAME2} to plugins`);
-    Se(import_picocolors2.default.green(`${PACKAGE_NAME2} installed successfully!`));
-  } catch (err) {
-    spinner.stop("Failed to install");
-    M2.error(err instanceof Error ? err.message : "Unknown error");
-    process.exit(1);
+  if (configureChoice === "customize") {
+    const userModels = opencodeConfig ? extractUserModels(opencodeConfig) : [];
+    const zenoxConfig = await readZenoxConfig();
+    const currentModels = getCurrentModels(zenoxConfig);
+    const selectedModels = await pickModelsForAllAgents(userModels, currentModels);
+    if (selectedModels === null) {
+      xe("Installation cancelled");
+      process.exit(0);
+    }
+    if (Object.keys(selectedModels).length > 0) {
+      const spinner = Y2();
+      spinner.start("Saving model configuration");
+      try {
+        await updateAgentModels(selectedModels);
+        spinner.stop(`Created ${getZenoxConfigPath()}`);
+      } catch (err) {
+        spinner.stop("Failed to save config");
+        M2.error(err instanceof Error ? err.message : "Unknown error");
+        process.exit(1);
+      }
+    } else {
+      M2.info("Using default models - no zenox.json needed");
+    }
   }
+  Se(import_picocolors3.default.green(`${PACKAGE_NAME} installed successfully!`));
 }
 async function runNonInteractive(cwd, customConfigPath) {
   const configFile = customConfigPath ? { path: customConfigPath, format: "json" } : findConfigFile(cwd);
   if (!configFile) {
-    console.log(`Creating opencode.json with ${PACKAGE_NAME2}...`);
+    console.log(`Creating opencode.json with ${PACKAGE_NAME}...`);
     const configPath = getDefaultConfigPath(cwd);
     await createDefaultConfig(configPath);
-    console.log(`Created opencode.json with ${PACKAGE_NAME2}`);
+    console.log(`Created opencode.json with ${PACKAGE_NAME}`);
+    console.log("Using default models (run 'bunx zenox config' to customize)");
     return;
   }
   const { config } = await readConfig(configFile.path);
   if (isPluginInstalled(config)) {
-    console.log(`${PACKAGE_NAME2} is already installed`);
+    console.log(`${PACKAGE_NAME} is already installed`);
     return;
   }
-  console.log(`Adding ${PACKAGE_NAME2} to ${configFile.path}...`);
+  console.log(`Adding ${PACKAGE_NAME} to ${configFile.path}...`);
   await installPlugin(configFile.path);
-  console.log(`${PACKAGE_NAME2} installed successfully!`);
+  console.log(`${PACKAGE_NAME} installed successfully!`);
+  console.log("Using default models (run 'bunx zenox config' to customize)");
+}
+
+// src/cli/config.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+async function runConfig() {
+  Ie(import_picocolors4.default.cyan(`${PACKAGE_NAME} model configurator`));
+  const cwd = process.cwd();
+  let userModels = [];
+  const configFile = findConfigFile(cwd);
+  if (configFile) {
+    try {
+      const { config } = await readConfig(configFile.path);
+      userModels = extractUserModels(config);
+    } catch {}
+  }
+  const zenoxConfig = await readZenoxConfig();
+  const currentModels = getCurrentModels(zenoxConfig);
+  M2.info("Current model configuration:");
+  for (const agent of AGENTS) {
+    const model = currentModels[agent.name] ?? agent.defaultModel;
+    const isCustom = currentModels[agent.name] !== undefined;
+    const suffix = isCustom ? import_picocolors4.default.yellow(" (custom)") : import_picocolors4.default.dim(" (default)");
+    M2.message(`  ${agent.displayName}: ${model}${suffix}`);
+  }
+  const selectedAgents = await selectAgentsToReconfigure(currentModels);
+  if (selectedAgents === null) {
+    xe("Configuration cancelled");
+    process.exit(0);
+  }
+  if (selectedAgents.length === 0) {
+    M2.warn("No agents selected");
+    Se(import_picocolors4.default.yellow("No changes made"));
+    return;
+  }
+  const newModels = {};
+  for (const agentName of selectedAgents) {
+    const agent = AGENTS.find((a) => a.name === agentName);
+    const current = currentModels[agentName];
+    const model = await pickModelForAgent(agent, userModels, current);
+    if (model === null) {
+      xe("Configuration cancelled");
+      process.exit(0);
+    }
+    if (model !== agent.defaultModel) {
+      newModels[agentName] = model;
+    } else {
+      newModels[agentName] = model;
+    }
+  }
+  const finalModels = {};
+  for (const [agent, model] of Object.entries(currentModels)) {
+    if (!selectedAgents.includes(agent)) {
+      finalModels[agent] = model;
+    }
+  }
+  for (const [agent, model] of Object.entries(newModels)) {
+    if (model !== DEFAULT_MODELS[agent]) {
+      finalModels[agent] = model;
+    }
+  }
+  if (Object.keys(finalModels).length > 0) {
+    const spinner = Y2();
+    spinner.start("Saving model configuration");
+    try {
+      await updateAgentModels(finalModels);
+      spinner.stop(`Updated ${getZenoxConfigPath()}`);
+    } catch (err) {
+      spinner.stop("Failed to save config");
+      M2.error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
+  } else {
+    M2.info("All agents using default models - zenox.json not needed");
+  }
+  Se(import_picocolors4.default.green("Configuration updated!"));
 }
 
 // src/cli/index.ts
 var program2 = new Command;
-program2.name("zenox").description("Zenox - OpenCode plugin for intelligent agent orchestration").version("0.1.0");
-program2.command("install").description("Add zenox to your opencode.json plugins").option("--no-tui", "Run in non-interactive mode").option("-c, --config <path>", "Path to opencode.json").action(async (options) => {
+program2.name("zenox").description("Zenox - OpenCode plugin for intelligent agent orchestration").version("1.0.0");
+program2.command("install").description("Add zenox to your opencode.json plugins and configure models").option("--no-tui", "Run in non-interactive mode (uses default models)").option("-c, --config <path>", "Path to opencode.json").action(async (options) => {
   try {
     await runInstall({
       noTui: !options.tui,
@@ -2974,4 +3577,12 @@ program2.command("install").description("Add zenox to your opencode.json plugins
     process.exit(1);
   }
 });
+program2.command("config").alias("models").description("Reconfigure sub-agent models").action(async () => {
+  try {
+    await runConfig();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
 program2.parse();

package/dist/cli/model-picker.d.ts

@@ -0,0 +1,7 @@
+import type { OpencodeConfig } from "./types";
+import type { AgentName, AgentInfo } from "./constants";
+export declare function extractUserModels(config: OpencodeConfig): string[];
+export declare function pickModelForAgent(agent: AgentInfo, userModels: string[], currentModel?: string): Promise<string | null>;
+export declare function pickModelsForAllAgents(userModels: string[], currentModels: Partial<Record<AgentName, string>>): Promise<Partial<Record<AgentName, string>> | null>;
+export declare function askConfigureModels(): Promise<"defaults" | "customize" | null>;
+export declare function selectAgentsToReconfigure(currentModels: Partial<Record<AgentName, string>>): Promise<AgentName[] | null>;

package/dist/cli/types.d.ts

@@ -1,5 +1,6 @@
 export interface OpencodeConfig {
     plugins?: string[];
+    plugin?: string[];
     [key: string]: unknown;
 }
 export interface InstallOptions {

package/dist/cli/zenox-config.d.ts

@@ -0,0 +1,16 @@
+import type { AgentName } from "./constants";
+export interface ZenoxConfigAgents {
+    [key: string]: {
+        model: string;
+    };
+}
+export interface ZenoxConfig {
+    agents?: ZenoxConfigAgents;
+    disabled_agents?: string[];
+    disabled_mcps?: string[];
+}
+export declare function getZenoxConfigPath(): string;
+export declare function readZenoxConfig(): Promise<ZenoxConfig | null>;
+export declare function writeZenoxConfig(config: ZenoxConfig): Promise<void>;
+export declare function updateAgentModels(models: Partial<Record<AgentName, string>>): Promise<void>;
+export declare function getCurrentModels(config: ZenoxConfig | null): Partial<Record<AgentName, string>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenox",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "OpenCode plugin with specialized agents (explorer, librarian, oracle, ui-planner), background tasks for parallel execution, and smart orchestration",
   "author": "Ayush",
   "license": "MIT",
@@ -54,6 +54,7 @@
     "@opencode-ai/sdk": "^1.1.12",
     "commander": "^14.0.0",
     "picocolors": "^1.1.1",
+    "strip-json-comments": "^5.0.3",
     "zod": "^3.24.1"
   },
   "devDependencies": {