oh-my-opencode-kikokikok 2.14.0 → 2.14.2

package/dist/cli/index.js

@@ -2253,7 +2253,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "oh-my-opencode-kikokikok",
-    version: "2.14.0",
+    version: "2.14.2",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -2355,6 +2355,7 @@ import { stripVTControlCharacters as S2 } from "util";
 
 // 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 "process";
 import * as g from "readline";
 import O from "readline";
@@ -2738,9 +2739,27 @@ class LD extends x {
     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}\u2588`;
+    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 "process";
 function ce() {
@@ -2773,13 +2792,13 @@ 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) => {
@@ -2787,39 +2806,60 @@ var G2 = (t) => {
   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, v, f) => {
-    const j2 = v === 0 && $2, E = v === f.length - 1 && g2;
-    return j2 || E ? import_picocolors.default.dim("...") : i(p2, v + l2 === n);
+  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 ve = (t) => {
   const n = (r2, i) => {
     const s = r2.label ?? String(r2.value);
     switch (i) {
       case "selected":
-        return `${import_picocolors.default.dim(s)}`;
+        return `${import_picocolors2.default.dim(s)}`;
       case "active":
-        return `${import_picocolors.default.green(k2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}`;
+        return `${import_picocolors2.default.green(k2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}`;
       case "cancelled":
-        return `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}`;
+        return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}`;
       default:
-        return `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(s)}`;
+        return `${import_picocolors2.default.dim(P2)} ${import_picocolors2.default.dim(s)}`;
     }
   };
   return new LD({ options: t.options, initialValue: t.initialValue, render() {
-    const r2 = `${import_picocolors.default.gray(o)}
+    const r2 = `${import_picocolors2.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `;
     switch (this.state) {
       case "submit":
-        return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
-${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 `${r2}${import_picocolors.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
-${import_picocolors.default.cyan(o)}  `)}
-${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();
@@ -2831,63 +2871,63 @@ ${t}
 `), i = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
     const $2 = S2(l2);
     return $2.length > a ? $2.length : a;
-  }, 0), i) + 2, c = r2.map((a) => `${import_picocolors.default.gray(o)}  ${import_picocolors.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors.default.gray(o)}`).join(`
+  }, 0), i) + 2, c = r2.map((a) => `${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors2.default.gray(o)}`).join(`
 `);
-  process.stdout.write(`${import_picocolors.default.gray(o)}
-${import_picocolors.default.green(C)}  ${import_picocolors.default.reset(n)} ${import_picocolors.default.gray(_2.repeat(Math.max(s - i - 1, 1)) + me)}
+  process.stdout.write(`${import_picocolors2.default.gray(o)}
+${import_picocolors2.default.green(C)}  ${import_picocolors2.default.reset(n)} ${import_picocolors2.default.gray(_2.repeat(Math.max(s - i - 1, 1)) + me)}
 ${c}
-${import_picocolors.default.gray(de + _2.repeat(s + 2) + pe)}
+${import_picocolors2.default.gray(de + _2.repeat(s + 2) + pe)}
 `);
 };
 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 J2 = `${import_picocolors.default.gray(o)}  `;
+var J2 = `${import_picocolors2.default.gray(o)}  `;
 var Y2 = ({ indicator: t = "dots" } = {}) => {
   const n = V2 ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "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;
@@ -2900,14 +2940,14 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
     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)}
+    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")
@@ -2920,7 +2960,7 @@ 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();
@@ -2931,7 +2971,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // 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 as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync, statSync } from "fs";
@@ -5598,29 +5638,37 @@ import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 var cachedPackageInfo = null;
+function isValidPackageJson(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.name === "string" && obj.name.length > 0;
+}
 function loadPackageJson() {
   if (cachedPackageInfo) {
     return cachedPackageInfo;
   }
+  const fallback = { name: "oh-my-opencode", version: "0.0.0" };
   try {
     const currentDir = dirname(fileURLToPath(import.meta.url));
     const possiblePaths = [
+      join(currentDir, "..", "package.json"),
       join(currentDir, "..", "..", "package.json"),
       join(currentDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of possiblePaths) {
       try {
         const content = readFileSync(pkgPath, "utf-8");
-        cachedPackageInfo = JSON.parse(content);
-        return cachedPackageInfo;
+        const parsed = JSON.parse(content);
+        if (isValidPackageJson(parsed)) {
+          cachedPackageInfo = parsed;
+          return cachedPackageInfo;
+        }
       } catch {
         continue;
       }
     }
-    cachedPackageInfo = { name: "oh-my-opencode", version: "0.0.0" };
+    cachedPackageInfo = fallback;
     return cachedPackageInfo;
   } catch {
-    cachedPackageInfo = { name: "oh-my-opencode", version: "0.0.0" };
+    cachedPackageInfo = fallback;
     return cachedPackageInfo;
   }
 }
@@ -6784,6 +6832,23 @@ function generateOmoConfig(installConfig) {
   if (installConfig.hasGemini) {
     config.google_auth = false;
   }
+  if (installConfig.memoryProvider === "mem0-cloud" || installConfig.memoryProvider === "mem0-local") {
+    config.mem0 = {
+      enabled: true,
+      userId: "default-user",
+      autoRehydrate: true,
+      rehydrateLayers: ["user", "project"],
+      ...installConfig.memoryProvider === "mem0-local" && installConfig.memoryEndpoint ? { endpoint: installConfig.memoryEndpoint } : {}
+    };
+  } else if (installConfig.memoryProvider === "letta") {
+    config.letta = {
+      enabled: true,
+      endpoint: installConfig.memoryEndpoint ?? "http://localhost:8283",
+      userId: "default-user",
+      autoRehydrate: true,
+      rehydrateLayers: ["user", "project"]
+    };
+  }
   const agents = {};
   if (!installConfig.hasClaude) {
     agents["Sisyphus"] = { model: "opencode/big-pickle" };
@@ -7098,7 +7163,8 @@ function detectCurrentConfig() {
     hasClaude: true,
     isMax20: true,
     hasChatGPT: true,
-    hasGemini: false
+    hasGemini: false,
+    memoryProvider: "no"
   };
   const { format: format2, path: path2 } = detectConfigFormat();
   if (format2 === "none") {
@@ -7150,89 +7216,98 @@ function detectCurrentConfig() {
     if (omoConfig.google_auth === false) {
       result.hasGemini = plugins.some((p2) => p2.startsWith("opencode-antigravity-auth"));
     }
+    if (omoConfig.letta?.enabled === true) {
+      result.memoryProvider = "letta";
+      result.memoryEndpoint = omoConfig.letta.endpoint;
+    } else if (omoConfig.mem0?.enabled === true) {
+      result.memoryProvider = omoConfig.mem0.endpoint ? "mem0-local" : "mem0-cloud";
+      result.memoryEndpoint = omoConfig.mem0.endpoint;
+    }
   } catch {}
   return result;
 }
 
 // src/cli/install.ts
 var SYMBOLS = {
-  check: import_picocolors2.default.green("\u2713"),
-  cross: import_picocolors2.default.red("\u2717"),
-  arrow: import_picocolors2.default.cyan("\u2192"),
-  bullet: import_picocolors2.default.dim("\u2022"),
-  info: import_picocolors2.default.blue("\u2139"),
-  warn: import_picocolors2.default.yellow("\u26A0"),
-  star: import_picocolors2.default.yellow("\u2605")
+  check: import_picocolors3.default.green("\u2713"),
+  cross: import_picocolors3.default.red("\u2717"),
+  arrow: import_picocolors3.default.cyan("\u2192"),
+  bullet: import_picocolors3.default.dim("\u2022"),
+  info: import_picocolors3.default.blue("\u2139"),
+  warn: import_picocolors3.default.yellow("\u26A0"),
+  star: import_picocolors3.default.yellow("\u2605")
 };
 function formatProvider(name, enabled, detail) {
-  const status = enabled ? SYMBOLS.check : import_picocolors2.default.dim("\u25CB");
-  const label = enabled ? import_picocolors2.default.white(name) : import_picocolors2.default.dim(name);
-  const suffix = detail ? import_picocolors2.default.dim(` (${detail})`) : "";
+  const status = enabled ? SYMBOLS.check : import_picocolors3.default.dim("\u25CB");
+  const label = enabled ? import_picocolors3.default.white(name) : import_picocolors3.default.dim(name);
+  const suffix = detail ? import_picocolors3.default.dim(` (${detail})`) : "";
   return `  ${status} ${label}${suffix}`;
 }
 function formatConfigSummary(config) {
   const lines = [];
-  lines.push(import_picocolors2.default.bold(import_picocolors2.default.white("Configuration Summary")));
+  lines.push(import_picocolors3.default.bold(import_picocolors3.default.white("Configuration Summary")));
   lines.push("");
   const claudeDetail = config.hasClaude ? config.isMax20 ? "max20" : "standard" : undefined;
   lines.push(formatProvider("Claude", config.hasClaude, claudeDetail));
   lines.push(formatProvider("ChatGPT", config.hasChatGPT));
   lines.push(formatProvider("Gemini", config.hasGemini));
+  const memoryLabel = config.memoryProvider === "no" ? "Memory" : config.memoryProvider === "mem0-cloud" ? "Memory (Mem0 Cloud)" : config.memoryProvider === "mem0-local" ? "Memory (Mem0 Self-hosted)" : "Memory (Letta)";
+  lines.push(formatProvider(memoryLabel, config.memoryProvider !== "no"));
   lines.push("");
-  lines.push(import_picocolors2.default.dim("\u2500".repeat(40)));
+  lines.push(import_picocolors3.default.dim("\u2500".repeat(40)));
   lines.push("");
-  lines.push(import_picocolors2.default.bold(import_picocolors2.default.white("Agent Configuration")));
+  lines.push(import_picocolors3.default.bold(import_picocolors3.default.white("Agent Configuration")));
   lines.push("");
   const sisyphusModel = config.hasClaude ? "claude-opus-4-5" : "big-pickle";
   const oracleModel = config.hasChatGPT ? "gpt-5.2" : config.hasClaude ? "claude-opus-4-5" : "big-pickle";
   const librarianModel = config.hasClaude && config.isMax20 ? "claude-sonnet-4-5" : "big-pickle";
   const frontendModel = config.hasGemini ? "gemini-3-pro-high" : config.hasClaude ? "claude-opus-4-5" : "big-pickle";
-  lines.push(`  ${SYMBOLS.bullet} Sisyphus     ${SYMBOLS.arrow} ${import_picocolors2.default.cyan(sisyphusModel)}`);
-  lines.push(`  ${SYMBOLS.bullet} Oracle       ${SYMBOLS.arrow} ${import_picocolors2.default.cyan(oracleModel)}`);
-  lines.push(`  ${SYMBOLS.bullet} Librarian    ${SYMBOLS.arrow} ${import_picocolors2.default.cyan(librarianModel)}`);
-  lines.push(`  ${SYMBOLS.bullet} Frontend     ${SYMBOLS.arrow} ${import_picocolors2.default.cyan(frontendModel)}`);
+  lines.push(`  ${SYMBOLS.bullet} Sisyphus     ${SYMBOLS.arrow} ${import_picocolors3.default.cyan(sisyphusModel)}`);
+  lines.push(`  ${SYMBOLS.bullet} Oracle       ${SYMBOLS.arrow} ${import_picocolors3.default.cyan(oracleModel)}`);
+  lines.push(`  ${SYMBOLS.bullet} Librarian    ${SYMBOLS.arrow} ${import_picocolors3.default.cyan(librarianModel)}`);
+  lines.push(`  ${SYMBOLS.bullet} Frontend     ${SYMBOLS.arrow} ${import_picocolors3.default.cyan(frontendModel)}`);
   return lines.join(`
 `);
 }
 function printHeader(isUpdate) {
   const mode = isUpdate ? "Update" : "Install";
   console.log();
-  console.log(import_picocolors2.default.bgMagenta(import_picocolors2.default.white(` oMoMoMoMo... ${mode} `)));
+  console.log(import_picocolors3.default.bgMagenta(import_picocolors3.default.white(` oMoMoMoMo... ${mode} `)));
   console.log();
 }
 function printStep(step, total, message) {
-  const progress = import_picocolors2.default.dim(`[${step}/${total}]`);
+  const progress = import_picocolors3.default.dim(`[${step}/${total}]`);
   console.log(`${progress} ${message}`);
 }
 function printSuccess(message) {
   console.log(`${SYMBOLS.check} ${message}`);
 }
 function printError(message) {
-  console.log(`${SYMBOLS.cross} ${import_picocolors2.default.red(message)}`);
+  console.log(`${SYMBOLS.cross} ${import_picocolors3.default.red(message)}`);
 }
 function printInfo(message) {
   console.log(`${SYMBOLS.info} ${message}`);
 }
 function printWarning(message) {
-  console.log(`${SYMBOLS.warn} ${import_picocolors2.default.yellow(message)}`);
+  console.log(`${SYMBOLS.warn} ${import_picocolors3.default.yellow(message)}`);
 }
 function printBox(content, title) {
   const lines = content.split(`
 `);
   const maxWidth = Math.max(...lines.map((l2) => l2.replace(/\x1b\[[0-9;]*m/g, "").length), title?.length ?? 0) + 4;
-  const border = import_picocolors2.default.dim("\u2500".repeat(maxWidth));
+  const border = import_picocolors3.default.dim("\u2500".repeat(maxWidth));
   console.log();
   if (title) {
-    console.log(import_picocolors2.default.dim("\u250C\u2500") + import_picocolors2.default.bold(` ${title} `) + import_picocolors2.default.dim("\u2500".repeat(maxWidth - title.length - 4)) + import_picocolors2.default.dim("\u2510"));
+    console.log(import_picocolors3.default.dim("\u250C\u2500") + import_picocolors3.default.bold(` ${title} `) + import_picocolors3.default.dim("\u2500".repeat(maxWidth - title.length - 4)) + import_picocolors3.default.dim("\u2510"));
   } else {
-    console.log(import_picocolors2.default.dim("\u250C") + border + import_picocolors2.default.dim("\u2510"));
+    console.log(import_picocolors3.default.dim("\u250C") + border + import_picocolors3.default.dim("\u2510"));
   }
   for (const line of lines) {
     const stripped = line.replace(/\x1b\[[0-9;]*m/g, "");
     const padding = maxWidth - stripped.length;
-    console.log(import_picocolors2.default.dim("\u2502") + ` ${line}${" ".repeat(padding - 1)}` + import_picocolors2.default.dim("\u2502"));
+    console.log(import_picocolors3.default.dim("\u2502") + ` ${line}${" ".repeat(padding - 1)}` + import_picocolors3.default.dim("\u2502"));
   }
-  console.log(import_picocolors2.default.dim("\u2514") + border + import_picocolors2.default.dim("\u2518"));
+  console.log(import_picocolors3.default.dim("\u2514") + border + import_picocolors3.default.dim("\u2518"));
   console.log();
 }
 function validateNonTuiArgs(args) {
@@ -7252,6 +7327,9 @@ function validateNonTuiArgs(args) {
   } else if (!["no", "yes"].includes(args.gemini)) {
     errors.push(`Invalid --gemini value: ${args.gemini} (expected: no, yes)`);
   }
+  if (args.memory !== undefined && !["no", "mem0-cloud", "mem0-local", "letta"].includes(args.memory)) {
+    errors.push(`Invalid --memory value: ${args.memory} (expected: no, mem0-cloud, mem0-local, letta)`);
+  }
   return { valid: errors.length === 0, errors };
 }
 function argsToConfig(args) {
@@ -7259,7 +7337,9 @@ function argsToConfig(args) {
     hasClaude: args.claude !== "no",
     isMax20: args.claude === "max20",
     hasChatGPT: args.chatgpt === "yes",
-    hasGemini: args.gemini === "yes"
+    hasGemini: args.gemini === "yes",
+    memoryProvider: args.memory ?? "no",
+    memoryEndpoint: args.memory === "mem0-local" || args.memory === "letta" ? args.memoryEndpoint ?? (args.memory === "letta" ? "http://localhost:8283" : "http://localhost:8000/v1") : undefined
   };
 }
 function detectedToInitialValues(detected) {
@@ -7270,7 +7350,8 @@ function detectedToInitialValues(detected) {
   return {
     claude,
     chatgpt: detected.hasChatGPT ? "yes" : "no",
-    gemini: detected.hasGemini ? "yes" : "no"
+    gemini: detected.hasGemini ? "yes" : "no",
+    memory: detected.memoryProvider
   };
 }
 async function runTuiMode(detected) {
@@ -7312,11 +7393,51 @@ async function runTuiMode(detected) {
     xe("Installation cancelled.");
     return null;
   }
+  const memory = await ve({
+    message: "Enable persistent memory for agent context?",
+    options: [
+      { value: "no", label: "No", hint: "Skip memory integration" },
+      { value: "mem0-cloud", label: "Mem0 Cloud (mem0.ai)", hint: "Requires MEM0_API_KEY env variable" },
+      { value: "mem0-local", label: "Mem0 Self-hosted", hint: "Uses custom Mem0 endpoint" },
+      { value: "letta", label: "Letta", hint: "Self-hosted Letta server (port 8283)" }
+    ],
+    initialValue: initial.memory
+  });
+  if (pD(memory)) {
+    xe("Installation cancelled.");
+    return null;
+  }
+  let memoryEndpoint;
+  if (memory === "mem0-local") {
+    const endpoint = await he({
+      message: "Enter Mem0 endpoint URL:",
+      placeholder: "http://localhost:8000/v1",
+      defaultValue: "http://localhost:8000/v1"
+    });
+    if (pD(endpoint)) {
+      xe("Installation cancelled.");
+      return null;
+    }
+    memoryEndpoint = endpoint || "http://localhost:8000/v1";
+  } else if (memory === "letta") {
+    const endpoint = await he({
+      message: "Enter Letta server URL:",
+      placeholder: "http://localhost:8283",
+      defaultValue: "http://localhost:8283"
+    });
+    if (pD(endpoint)) {
+      xe("Installation cancelled.");
+      return null;
+    }
+    memoryEndpoint = endpoint || "http://localhost:8283";
+  }
   return {
     hasClaude: claude !== "no",
     isMax20: claude === "max20",
     hasChatGPT: chatgpt === "yes",
-    hasGemini: gemini === "yes"
+    hasGemini: gemini === "yes",
+    memoryProvider: memory,
+    memoryEndpoint
   };
 }
 async function runNonTuiInstall(args) {
@@ -7357,7 +7478,7 @@ async function runNonTuiInstall(args) {
     printError(`Failed: ${pluginResult.error}`);
     return 1;
   }
-  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${import_picocolors2.default.dim(pluginResult.configPath)}`);
+  printSuccess(`Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${import_picocolors3.default.dim(pluginResult.configPath)}`);
   if (config.hasGemini || config.hasChatGPT) {
     printStep(step++, totalSteps, "Adding auth plugins...");
     const authResult = await addAuthPlugins(config);
@@ -7365,14 +7486,14 @@ async function runNonTuiInstall(args) {
       printError(`Failed: ${authResult.error}`);
       return 1;
     }
-    printSuccess(`Auth plugins configured ${SYMBOLS.arrow} ${import_picocolors2.default.dim(authResult.configPath)}`);
+    printSuccess(`Auth plugins configured ${SYMBOLS.arrow} ${import_picocolors3.default.dim(authResult.configPath)}`);
     printStep(step++, totalSteps, "Adding provider configurations...");
     const providerResult = addProviderConfig(config);
     if (!providerResult.success) {
       printError(`Failed: ${providerResult.error}`);
       return 1;
     }
-    printSuccess(`Providers configured ${SYMBOLS.arrow} ${import_picocolors2.default.dim(providerResult.configPath)}`);
+    printSuccess(`Providers configured ${SYMBOLS.arrow} ${import_picocolors3.default.dim(providerResult.configPath)}`);
   } else {
     step += 2;
   }
@@ -7383,7 +7504,7 @@ async function runNonTuiInstall(args) {
       printError(`Failed: ${hotfixResult.error}`);
       return 1;
     }
-    printSuccess(`Hotfix configured ${SYMBOLS.arrow} ${import_picocolors2.default.dim(hotfixResult.configPath)}`);
+    printSuccess(`Hotfix configured ${SYMBOLS.arrow} ${import_picocolors3.default.dim(hotfixResult.configPath)}`);
     printInfo("Installing dependencies with bun...");
     const bunSuccess = await runBunInstall();
     if (bunSuccess) {
@@ -7400,35 +7521,35 @@ async function runNonTuiInstall(args) {
     printError(`Failed: ${omoResult.error}`);
     return 1;
   }
-  printSuccess(`Config written ${SYMBOLS.arrow} ${import_picocolors2.default.dim(omoResult.configPath)}`);
+  printSuccess(`Config written ${SYMBOLS.arrow} ${import_picocolors3.default.dim(omoResult.configPath)}`);
   printBox(formatConfigSummary(config), isUpdate ? "Updated Configuration" : "Installation Complete");
   if (!config.hasClaude && !config.hasChatGPT && !config.hasGemini) {
     printWarning("No model providers configured. Using opencode/big-pickle as fallback.");
   }
   if ((config.hasClaude || config.hasChatGPT || config.hasGemini) && !args.skipAuth) {
-    console.log(import_picocolors2.default.bold("Next Steps - Authenticate your providers:"));
+    console.log(import_picocolors3.default.bold("Next Steps - Authenticate your providers:"));
     console.log();
     if (config.hasClaude) {
-      console.log(`  ${SYMBOLS.arrow} ${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select Anthropic \u2192 Claude Pro/Max)")}`);
+      console.log(`  ${SYMBOLS.arrow} ${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select Anthropic \u2192 Claude Pro/Max)")}`);
     }
     if (config.hasChatGPT) {
-      console.log(`  ${SYMBOLS.arrow} ${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select OpenAI \u2192 ChatGPT Plus/Pro)")}`);
+      console.log(`  ${SYMBOLS.arrow} ${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select OpenAI \u2192 ChatGPT Plus/Pro)")}`);
     }
     if (config.hasGemini) {
-      console.log(`  ${SYMBOLS.arrow} ${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select Google \u2192 OAuth with Antigravity)")}`);
+      console.log(`  ${SYMBOLS.arrow} ${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select Google \u2192 OAuth with Antigravity)")}`);
     }
     console.log();
   }
-  console.log(`${SYMBOLS.star} ${import_picocolors2.default.bold(import_picocolors2.default.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`);
-  console.log(`  Run ${import_picocolors2.default.cyan("opencode")} to start!`);
+  console.log(`${SYMBOLS.star} ${import_picocolors3.default.bold(import_picocolors3.default.green(isUpdate ? "Configuration updated!" : "Installation complete!"))}`);
+  console.log(`  Run ${import_picocolors3.default.cyan("opencode")} to start!`);
   console.log();
-  printBox(`${import_picocolors2.default.bold("Pro Tip:")} Include ${import_picocolors2.default.cyan("ultrawork")} (or ${import_picocolors2.default.cyan("ulw")}) in your prompt.
+  printBox(`${import_picocolors3.default.bold("Pro Tip:")} Include ${import_picocolors3.default.cyan("ultrawork")} (or ${import_picocolors3.default.cyan("ulw")}) in your prompt.
 ` + `All features work like magic\u2014parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "\uD83E\uDE84 The Magic Word");
-  console.log(`${SYMBOLS.star} ${import_picocolors2.default.yellow("If you found this helpful, consider starring the repo!")}`);
-  console.log(`  ${import_picocolors2.default.dim("gh repo star code-yeongyu/oh-my-opencode")}`);
+  console.log(`${SYMBOLS.star} ${import_picocolors3.default.yellow("If you found this helpful, consider starring the repo!")}`);
+  console.log(`  ${import_picocolors3.default.dim("gh repo star code-yeongyu/oh-my-opencode")}`);
   console.log();
-  console.log(import_picocolors2.default.dim("oMoMoMoMo... Enjoy!"));
+  console.log(import_picocolors3.default.dim("oMoMoMoMo... Enjoy!"));
   console.log();
   return 0;
 }
@@ -7438,7 +7559,7 @@ async function install(args) {
   }
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
-  Ie(import_picocolors2.default.bgMagenta(import_picocolors2.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
+  Ie(import_picocolors3.default.bgMagenta(import_picocolors3.default.white(isUpdate ? " oMoMoMoMo... Update " : " oMoMoMoMo... ")));
   if (isUpdate) {
     const initial = detectedToInitialValues(detected);
     M2.info(`Existing configuration detected: Claude=${initial.claude}, ChatGPT=${initial.chatgpt}, Gemini=${initial.gemini}`);
@@ -7450,11 +7571,11 @@ async function install(args) {
     s.stop("OpenCode is not installed");
     M2.error("OpenCode is not installed on this system.");
     Me("Visit https://opencode.ai/docs for installation instructions", "Installation Guide");
-    Se(import_picocolors2.default.red("Please install OpenCode first."));
+    Se(import_picocolors3.default.red("Please install OpenCode first."));
     return 1;
   }
   const version = await getOpenCodeVersion();
-  s.stop(`OpenCode ${version ?? "installed"} ${import_picocolors2.default.green("\u2713")}`);
+  s.stop(`OpenCode ${version ?? "installed"} ${import_picocolors3.default.green("\u2713")}`);
   const config = await runTuiMode(detected);
   if (!config)
     return 1;
@@ -7462,53 +7583,53 @@ async function install(args) {
   const pluginResult = addPluginToOpenCodeConfig();
   if (!pluginResult.success) {
     s.stop(`Failed to add plugin: ${pluginResult.error}`);
-    Se(import_picocolors2.default.red("Installation failed."));
+    Se(import_picocolors3.default.red("Installation failed."));
     return 1;
   }
-  s.stop(`Plugin added to ${import_picocolors2.default.cyan(pluginResult.configPath)}`);
+  s.stop(`Plugin added to ${import_picocolors3.default.cyan(pluginResult.configPath)}`);
   if (config.hasGemini || config.hasChatGPT) {
     s.start("Adding auth plugins (fetching latest versions)");
     const authResult = await addAuthPlugins(config);
     if (!authResult.success) {
       s.stop(`Failed to add auth plugins: ${authResult.error}`);
-      Se(import_picocolors2.default.red("Installation failed."));
+      Se(import_picocolors3.default.red("Installation failed."));
       return 1;
     }
-    s.stop(`Auth plugins added to ${import_picocolors2.default.cyan(authResult.configPath)}`);
+    s.stop(`Auth plugins added to ${import_picocolors3.default.cyan(authResult.configPath)}`);
     s.start("Adding provider configurations");
     const providerResult = addProviderConfig(config);
     if (!providerResult.success) {
       s.stop(`Failed to add provider config: ${providerResult.error}`);
-      Se(import_picocolors2.default.red("Installation failed."));
+      Se(import_picocolors3.default.red("Installation failed."));
       return 1;
     }
-    s.stop(`Provider config added to ${import_picocolors2.default.cyan(providerResult.configPath)}`);
+    s.stop(`Provider config added to ${import_picocolors3.default.cyan(providerResult.configPath)}`);
   }
   if (config.hasChatGPT) {
     s.start("Setting up ChatGPT hotfix");
     const hotfixResult = setupChatGPTHotfix();
     if (!hotfixResult.success) {
       s.stop(`Failed to setup hotfix: ${hotfixResult.error}`);
-      Se(import_picocolors2.default.red("Installation failed."));
+      Se(import_picocolors3.default.red("Installation failed."));
       return 1;
     }
-    s.stop(`Hotfix configured in ${import_picocolors2.default.cyan(hotfixResult.configPath)}`);
+    s.stop(`Hotfix configured in ${import_picocolors3.default.cyan(hotfixResult.configPath)}`);
     s.start("Installing dependencies with bun");
     const bunSuccess = await runBunInstall();
     if (bunSuccess) {
       s.stop("Dependencies installed");
     } else {
-      s.stop(import_picocolors2.default.yellow("bun install failed - run manually: cd ~/.config/opencode && bun i"));
+      s.stop(import_picocolors3.default.yellow("bun install failed - run manually: cd ~/.config/opencode && bun i"));
     }
   }
   s.start("Writing oh-my-opencode configuration");
   const omoResult = writeOmoConfig(config);
   if (!omoResult.success) {
     s.stop(`Failed to write config: ${omoResult.error}`);
-    Se(import_picocolors2.default.red("Installation failed."));
+    Se(import_picocolors3.default.red("Installation failed."));
     return 1;
   }
-  s.stop(`Config written to ${import_picocolors2.default.cyan(omoResult.configPath)}`);
+  s.stop(`Config written to ${import_picocolors3.default.cyan(omoResult.configPath)}`);
   if (!config.hasClaude && !config.hasChatGPT && !config.hasGemini) {
     M2.warn("No model providers configured. Using opencode/big-pickle as fallback.");
   }
@@ -7516,25 +7637,25 @@ async function install(args) {
   if ((config.hasClaude || config.hasChatGPT || config.hasGemini) && !args.skipAuth) {
     const steps = [];
     if (config.hasClaude) {
-      steps.push(`${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select Anthropic \u2192 Claude Pro/Max)")}`);
+      steps.push(`${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select Anthropic \u2192 Claude Pro/Max)")}`);
     }
     if (config.hasChatGPT) {
-      steps.push(`${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select OpenAI \u2192 ChatGPT Plus/Pro)")}`);
+      steps.push(`${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select OpenAI \u2192 ChatGPT Plus/Pro)")}`);
     }
     if (config.hasGemini) {
-      steps.push(`${import_picocolors2.default.dim("opencode auth login")} ${import_picocolors2.default.gray("(select Google \u2192 OAuth with Antigravity)")}`);
+      steps.push(`${import_picocolors3.default.dim("opencode auth login")} ${import_picocolors3.default.gray("(select Google \u2192 OAuth with Antigravity)")}`);
     }
     Me(steps.join(`
 `), "Next Steps - Authenticate your providers");
   }
-  M2.success(import_picocolors2.default.bold(isUpdate ? "Configuration updated!" : "Installation complete!"));
-  M2.message(`Run ${import_picocolors2.default.cyan("opencode")} to start!`);
-  Me(`Include ${import_picocolors2.default.cyan("ultrawork")} (or ${import_picocolors2.default.cyan("ulw")}) in your prompt.
+  M2.success(import_picocolors3.default.bold(isUpdate ? "Configuration updated!" : "Installation complete!"));
+  M2.message(`Run ${import_picocolors3.default.cyan("opencode")} to start!`);
+  Me(`Include ${import_picocolors3.default.cyan("ultrawork")} (or ${import_picocolors3.default.cyan("ulw")}) in your prompt.
 ` + `All features work like magic\u2014parallel agents, background tasks,
 ` + `deep exploration, and relentless execution until completion.`, "\uD83E\uDE84 The Magic Word");
-  M2.message(`${import_picocolors2.default.yellow("\u2605")} If you found this helpful, consider starring the repo!`);
-  M2.message(`  ${import_picocolors2.default.dim("gh repo star code-yeongyu/oh-my-opencode")}`);
-  Se(import_picocolors2.default.green("oMoMoMoMo... Enjoy!"));
+  M2.message(`${import_picocolors3.default.yellow("\u2605")} If you found this helpful, consider starring the repo!`);
+  M2.message(`  ${import_picocolors3.default.dim("gh repo star code-yeongyu/oh-my-opencode")}`);
+  Se(import_picocolors3.default.green("oMoMoMoMo... Enjoy!"));
   return 0;
 }
 // node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
@@ -7705,7 +7826,7 @@ var separatorObjectExplode = (style) => {
 };
 var serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
   if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    const joinedValues2 = (allowReserved ? value : value.map((v2) => encodeURIComponent(v2))).join(separatorArrayNoExplode(style));
     switch (style) {
       case "label":
         return `.${joinedValues2}`;
@@ -7718,14 +7839,14 @@ var serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
     }
   }
   const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
+  const joinedValues = value.map((v2) => {
     if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
+      return allowReserved ? v2 : encodeURIComponent(v2);
     }
     return serializePrimitiveParam({
       allowReserved,
       name,
-      value: v
+      value: v2
     });
   }).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
@@ -7745,8 +7866,8 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
   }
   if (style !== "deepObject" && !explode) {
     let values = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    Object.entries(value).forEach(([key, v2]) => {
+      values = [...values, key, allowReserved ? v2 : encodeURIComponent(v2)];
     });
     const joinedValues2 = values.join(",");
     switch (style) {
@@ -7761,10 +7882,10 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
     }
   }
   const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+  const joinedValues = Object.entries(value).map(([key, v2]) => serializePrimitiveParam({
     allowReserved,
     name: style === "deepObject" ? `${name}[${key}]` : key,
-    value: v
+    value: v2
   })).join(separator);
   return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
 };
@@ -7968,8 +8089,8 @@ var mergeHeaders = (...headers) => {
       if (value === null) {
         mergedHeaders.delete(key);
       } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
+        for (const v2 of value) {
+          mergedHeaders.append(key, v2);
         }
       } else if (value !== undefined) {
         mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
@@ -8977,10 +9098,10 @@ async function createOpencode(options) {
 }
 
 // src/cli/run/runner.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 
 // src/cli/run/completion.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors4 = __toESM(require_picocolors(), 1);
 async function checkCompletionConditions(ctx) {
   try {
     if (!await areAllTodosComplete(ctx)) {
@@ -8991,7 +9112,7 @@ async function checkCompletionConditions(ctx) {
     }
     return true;
   } catch (err) {
-    console.error(import_picocolors3.default.red(`[completion] API error: ${err}`));
+    console.error(import_picocolors4.default.red(`[completion] API error: ${err}`));
     return false;
   }
 }
@@ -9000,7 +9121,7 @@ async function areAllTodosComplete(ctx) {
   const todos = todosRes.data ?? [];
   const incompleteTodos = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
   if (incompleteTodos.length > 0) {
-    console.log(import_picocolors3.default.dim(`  Waiting: ${incompleteTodos.length} todos remaining`));
+    console.log(import_picocolors4.default.dim(`  Waiting: ${incompleteTodos.length} todos remaining`));
     return false;
   }
   return true;
@@ -9021,7 +9142,7 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
   for (const child of children) {
     const status = allStatuses[child.id];
     if (status && status.type !== "idle") {
-      console.log(import_picocolors3.default.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`));
+      console.log(import_picocolors4.default.dim(`  Waiting: session ${child.id.slice(0, 8)}... is ${status.type}`));
       return false;
     }
     const descendantsIdle = await areAllDescendantsIdle(ctx, child.id, allStatuses);
@@ -9033,7 +9154,7 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
 }
 
 // src/cli/run/events.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
+var import_picocolors5 = __toESM(require_picocolors(), 1);
 function createEventState() {
   return {
     mainSessionIdle: false,
@@ -9051,7 +9172,7 @@ async function processEvents(ctx, stream, state) {
     try {
       const payload = event;
       if (!payload?.type) {
-        console.error(import_picocolors4.default.dim(`[event] no type: ${JSON.stringify(event)}`));
+        console.error(import_picocolors5.default.dim(`[event] no type: ${JSON.stringify(event)}`));
         continue;
       }
       logEventVerbose(ctx, payload);
@@ -9063,7 +9184,7 @@ async function processEvents(ctx, stream, state) {
       handleToolExecute(ctx, payload, state);
       handleToolResult(ctx, payload, state);
     } catch (err) {
-      console.error(import_picocolors4.default.red(`[event error] ${err}`));
+      console.error(import_picocolors5.default.red(`[event error] ${err}`));
     }
   }
 }
@@ -9072,12 +9193,12 @@ function logEventVerbose(ctx, payload) {
   const info = props?.info;
   const sessionID = props?.sessionID ?? info?.sessionID;
   const isMainSession = sessionID === ctx.sessionID;
-  const sessionTag = isMainSession ? import_picocolors4.default.green("[MAIN]") : import_picocolors4.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
+  const sessionTag = isMainSession ? import_picocolors5.default.green("[MAIN]") : import_picocolors5.default.yellow(`[${String(sessionID).slice(0, 8)}]`);
   switch (payload.type) {
     case "session.idle":
     case "session.status": {
       const status = props?.status?.type ?? "idle";
-      console.error(import_picocolors4.default.dim(`${sessionTag} ${payload.type}: ${status}`));
+      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}: ${status}`));
       break;
     }
     case "message.part.updated": {
@@ -9085,7 +9206,7 @@ function logEventVerbose(ctx, payload) {
       const part = partProps?.part;
       if (part?.type === "tool-invocation") {
         const toolPart = part;
-        console.error(import_picocolors4.default.dim(`${sessionTag} message.part (tool): ${toolPart.toolName} [${toolPart.state}]`));
+        console.error(import_picocolors5.default.dim(`${sessionTag} message.part (tool): ${toolPart.toolName} [${toolPart.state}]`));
       }
       break;
     }
@@ -9094,7 +9215,7 @@ function logEventVerbose(ctx, payload) {
       const role = msgProps?.info?.role ?? "unknown";
       const content = msgProps?.content ?? "";
       const preview = content.slice(0, 100).replace(/\n/g, "\\n");
-      console.error(import_picocolors4.default.dim(`${sessionTag} message.updated (${role}): "${preview}${content.length > 100 ? "..." : ""}"`));
+      console.error(import_picocolors5.default.dim(`${sessionTag} message.updated (${role}): "${preview}${content.length > 100 ? "..." : ""}"`));
       break;
     }
     case "tool.execute": {
@@ -9102,19 +9223,19 @@ function logEventVerbose(ctx, payload) {
       const toolName = toolProps?.name ?? "unknown";
       const input = toolProps?.input ?? {};
       const inputStr = JSON.stringify(input).slice(0, 150);
-      console.error(import_picocolors4.default.cyan(`${sessionTag} \u26A1 TOOL.EXECUTE: ${import_picocolors4.default.bold(toolName)}`));
-      console.error(import_picocolors4.default.dim(`   input: ${inputStr}${inputStr.length >= 150 ? "..." : ""}`));
+      console.error(import_picocolors5.default.cyan(`${sessionTag} \u26A1 TOOL.EXECUTE: ${import_picocolors5.default.bold(toolName)}`));
+      console.error(import_picocolors5.default.dim(`   input: ${inputStr}${inputStr.length >= 150 ? "..." : ""}`));
       break;
     }
     case "tool.result": {
       const resultProps = props;
       const output = resultProps?.output ?? "";
       const preview = output.slice(0, 200).replace(/\n/g, "\\n");
-      console.error(import_picocolors4.default.green(`${sessionTag} \u2713 TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
+      console.error(import_picocolors5.default.green(`${sessionTag} \u2713 TOOL.RESULT: "${preview}${output.length > 200 ? "..." : ""}"`));
       break;
     }
     default:
-      console.error(import_picocolors4.default.dim(`${sessionTag} ${payload.type}`));
+      console.error(import_picocolors5.default.dim(`${sessionTag} ${payload.type}`));
   }
 }
 function handleSessionIdle(ctx, payload, state) {
@@ -9140,7 +9261,7 @@ function handleSessionError(ctx, payload, state) {
   if (props?.sessionID === ctx.sessionID) {
     state.mainSessionError = true;
     state.lastError = props?.error ? String(props.error instanceof Error ? props.error.message : props.error) : "Unknown error";
-    console.error(import_picocolors4.default.red(`
+    console.error(import_picocolors5.default.red(`
 [session.error] ${state.lastError}`));
   }
 }
@@ -9194,17 +9315,17 @@ function handleToolExecute(ctx, payload, state) {
   if (props?.input) {
     const input = props.input;
     if (input.command) {
-      inputPreview = ` ${import_picocolors4.default.dim(String(input.command).slice(0, 60))}`;
+      inputPreview = ` ${import_picocolors5.default.dim(String(input.command).slice(0, 60))}`;
     } else if (input.pattern) {
-      inputPreview = ` ${import_picocolors4.default.dim(String(input.pattern).slice(0, 40))}`;
+      inputPreview = ` ${import_picocolors5.default.dim(String(input.pattern).slice(0, 40))}`;
     } else if (input.filePath) {
-      inputPreview = ` ${import_picocolors4.default.dim(String(input.filePath))}`;
+      inputPreview = ` ${import_picocolors5.default.dim(String(input.filePath))}`;
     } else if (input.query) {
-      inputPreview = ` ${import_picocolors4.default.dim(String(input.query).slice(0, 40))}`;
+      inputPreview = ` ${import_picocolors5.default.dim(String(input.query).slice(0, 40))}`;
     }
   }
   process.stdout.write(`
-${import_picocolors4.default.cyan("\u26A1")} ${import_picocolors4.default.bold(toolName)}${inputPreview}
+${import_picocolors5.default.cyan("\u26A1")} ${import_picocolors5.default.bold(toolName)}${inputPreview}
 `);
 }
 function handleToolResult(ctx, payload, state) {
@@ -9219,7 +9340,7 @@ function handleToolResult(ctx, payload, state) {
   if (preview.trim()) {
     const lines = preview.split(`
 `).slice(0, 3);
-    process.stdout.write(import_picocolors4.default.dim(`   \u2514\u2500 ${lines.join(`
+    process.stdout.write(import_picocolors5.default.dim(`   \u2514\u2500 ${lines.join(`
       `)}
 `));
   }
@@ -9237,12 +9358,12 @@ async function run(options) {
     directory = process.cwd(),
     timeout = DEFAULT_TIMEOUT_MS
   } = options;
-  console.log(import_picocolors5.default.cyan("Starting opencode server..."));
+  console.log(import_picocolors6.default.cyan("Starting opencode server..."));
   const abortController = new AbortController;
   let timeoutId = null;
   if (timeout > 0) {
     timeoutId = setTimeout(() => {
-      console.log(import_picocolors5.default.yellow(`
+      console.log(import_picocolors6.default.yellow(`
 Timeout reached. Aborting...`));
       abortController.abort();
     }, timeout);
@@ -9257,7 +9378,7 @@ Timeout reached. Aborting...`));
       server2.close();
     };
     process.on("SIGINT", () => {
-      console.log(import_picocolors5.default.yellow(`
+      console.log(import_picocolors6.default.yellow(`
 Interrupted. Shutting down...`));
       cleanup();
       process.exit(130);
@@ -9268,10 +9389,10 @@ Interrupted. Shutting down...`));
       });
       const sessionID = sessionRes.data?.id;
       if (!sessionID) {
-        console.error(import_picocolors5.default.red("Failed to create session"));
+        console.error(import_picocolors6.default.red("Failed to create session"));
         return 1;
       }
-      console.log(import_picocolors5.default.dim(`Session: ${sessionID}`));
+      console.log(import_picocolors6.default.dim(`Session: ${sessionID}`));
       const ctx = {
         client: client3,
         sessionID,
@@ -9281,7 +9402,7 @@ Interrupted. Shutting down...`));
       const events = await client3.event.subscribe();
       const eventState = createEventState();
       const eventProcessor = processEvents(ctx, events.stream, eventState);
-      console.log(import_picocolors5.default.dim(`
+      console.log(import_picocolors6.default.dim(`
 Sending prompt...`));
       await client3.session.promptAsync({
         path: { id: sessionID },
@@ -9291,7 +9412,7 @@ Sending prompt...`));
         },
         query: { directory }
       });
-      console.log(import_picocolors5.default.dim(`Waiting for completion...
+      console.log(import_picocolors6.default.dim(`Waiting for completion...
 `));
       while (!abortController.signal.aborted) {
         await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
@@ -9299,16 +9420,16 @@ Sending prompt...`));
           continue;
         }
         if (eventState.mainSessionError) {
-          console.error(import_picocolors5.default.red(`
+          console.error(import_picocolors6.default.red(`
 
 Session ended with error: ${eventState.lastError}`));
-          console.error(import_picocolors5.default.yellow("Check if todos were completed before the error."));
+          console.error(import_picocolors6.default.yellow("Check if todos were completed before the error."));
           cleanup();
           process.exit(1);
         }
         const shouldExit = await checkCompletionConditions(ctx);
         if (shouldExit) {
-          console.log(import_picocolors5.default.green(`
+          console.log(import_picocolors6.default.green(`
 
 All tasks completed.`));
           cleanup();
@@ -9328,7 +9449,7 @@ All tasks completed.`));
     if (err instanceof Error && err.name === "AbortError") {
       return 130;
     }
-    console.error(import_picocolors5.default.red(`Error: ${err}`));
+    console.error(import_picocolors6.default.red(`Error: ${err}`));
     return 1;
   }
 }
@@ -9519,54 +9640,54 @@ async function getLatestVersion() {
 }
 
 // src/cli/get-local-version/formatter.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 var SYMBOLS2 = {
-  check: import_picocolors6.default.green("\u2713"),
-  cross: import_picocolors6.default.red("\u2717"),
-  arrow: import_picocolors6.default.cyan("\u2192"),
-  info: import_picocolors6.default.blue("\u2139"),
-  warn: import_picocolors6.default.yellow("\u26A0"),
-  pin: import_picocolors6.default.magenta("\uD83D\uDCCC"),
-  dev: import_picocolors6.default.cyan("\uD83D\uDD27")
+  check: import_picocolors7.default.green("\u2713"),
+  cross: import_picocolors7.default.red("\u2717"),
+  arrow: import_picocolors7.default.cyan("\u2192"),
+  info: import_picocolors7.default.blue("\u2139"),
+  warn: import_picocolors7.default.yellow("\u26A0"),
+  pin: import_picocolors7.default.magenta("\uD83D\uDCCC"),
+  dev: import_picocolors7.default.cyan("\uD83D\uDD27")
 };
 function formatVersionOutput(info) {
   const packageName = getPackageName();
   const lines = [];
   lines.push("");
-  lines.push(import_picocolors6.default.bold(import_picocolors6.default.white(`${packageName} Version Information`)));
-  lines.push(import_picocolors6.default.dim("\u2500".repeat(50)));
+  lines.push(import_picocolors7.default.bold(import_picocolors7.default.white(`${packageName} Version Information`)));
+  lines.push(import_picocolors7.default.dim("\u2500".repeat(50)));
   lines.push("");
   if (info.currentVersion) {
-    lines.push(`  Current Version: ${import_picocolors6.default.cyan(info.currentVersion)}`);
+    lines.push(`  Current Version: ${import_picocolors7.default.cyan(info.currentVersion)}`);
   } else {
-    lines.push(`  Current Version: ${import_picocolors6.default.dim("unknown")}`);
+    lines.push(`  Current Version: ${import_picocolors7.default.dim("unknown")}`);
   }
   if (!info.isLocalDev && info.latestVersion) {
-    lines.push(`  Latest Version:  ${import_picocolors6.default.cyan(info.latestVersion)}`);
+    lines.push(`  Latest Version:  ${import_picocolors7.default.cyan(info.latestVersion)}`);
   }
   lines.push("");
   switch (info.status) {
     case "up-to-date":
-      lines.push(`  ${SYMBOLS2.check} ${import_picocolors6.default.green("You're up to date!")}`);
+      lines.push(`  ${SYMBOLS2.check} ${import_picocolors7.default.green("You're up to date!")}`);
       break;
     case "outdated":
-      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors6.default.yellow("Update available")}`);
-      lines.push(`  ${import_picocolors6.default.dim("Run:")} ${import_picocolors6.default.cyan(`cd ~/.config/opencode && bun update ${packageName}`)}`);
+      lines.push(`  ${SYMBOLS2.warn} ${import_picocolors7.default.yellow("Update available")}`);
+      lines.push(`  ${import_picocolors7.default.dim("Run:")} ${import_picocolors7.default.cyan(`cd ~/.config/opencode && bun update ${packageName}`)}`);
       break;
     case "local-dev":
-      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors6.default.cyan("Running in local development mode")}`);
-      lines.push(`  ${import_picocolors6.default.dim("Using file:// protocol from config")}`);
+      lines.push(`  ${SYMBOLS2.dev} ${import_picocolors7.default.cyan("Running in local development mode")}`);
+      lines.push(`  ${import_picocolors7.default.dim("Using file:// protocol from config")}`);
       break;
     case "pinned":
-      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors6.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
-      lines.push(`  ${import_picocolors6.default.dim("Update check skipped for pinned versions")}`);
+      lines.push(`  ${SYMBOLS2.pin} ${import_picocolors7.default.magenta(`Version pinned to ${info.pinnedVersion}`)}`);
+      lines.push(`  ${import_picocolors7.default.dim("Update check skipped for pinned versions")}`);
       break;
     case "error":
-      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors6.default.red("Unable to check for updates")}`);
-      lines.push(`  ${import_picocolors6.default.dim("Network error or npm registry unavailable")}`);
+      lines.push(`  ${SYMBOLS2.cross} ${import_picocolors7.default.red("Unable to check for updates")}`);
+      lines.push(`  ${import_picocolors7.default.dim("Network error or npm registry unavailable")}`);
       break;
     case "unknown":
-      lines.push(`  ${SYMBOLS2.info} ${import_picocolors6.default.yellow("Version information unavailable")}`);
+      lines.push(`  ${SYMBOLS2.info} ${import_picocolors7.default.yellow("Version information unavailable")}`);
       break;
   }
   lines.push("");
@@ -9665,21 +9786,21 @@ async function getLocalVersion(options = {}) {
 }
 
 // src/cli/doctor/constants.ts
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 var SYMBOLS3 = {
-  check: import_picocolors7.default.green("\u2713"),
-  cross: import_picocolors7.default.red("\u2717"),
-  warn: import_picocolors7.default.yellow("\u26A0"),
-  info: import_picocolors7.default.blue("\u2139"),
-  arrow: import_picocolors7.default.cyan("\u2192"),
-  bullet: import_picocolors7.default.dim("\u2022"),
-  skip: import_picocolors7.default.dim("\u25CB")
+  check: import_picocolors8.default.green("\u2713"),
+  cross: import_picocolors8.default.red("\u2717"),
+  warn: import_picocolors8.default.yellow("\u26A0"),
+  info: import_picocolors8.default.blue("\u2139"),
+  arrow: import_picocolors8.default.cyan("\u2192"),
+  bullet: import_picocolors8.default.dim("\u2022"),
+  skip: import_picocolors8.default.dim("\u25CB")
 };
 var STATUS_COLORS = {
-  pass: import_picocolors7.default.green,
-  fail: import_picocolors7.default.red,
-  warn: import_picocolors7.default.yellow,
-  skip: import_picocolors7.default.dim
+  pass: import_picocolors8.default.green,
+  fail: import_picocolors8.default.red,
+  warn: import_picocolors8.default.yellow,
+  skip: import_picocolors8.default.dim
 };
 var CHECK_IDS = {
   OPENCODE_INSTALLATION: "opencode-installation",
@@ -9759,8 +9880,8 @@ async function getOpenCodeVersion2(binary2) {
   return null;
 }
 function compareVersions(current, minimum) {
-  const parseVersion = (v) => {
-    const cleaned = v.replace(/^v/, "").split("-")[0];
+  const parseVersion = (v2) => {
+    const cleaned = v2.replace(/^v/, "").split("-")[0];
     return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
   };
   const curr = parseVersion(current);
@@ -10584,8 +10705,8 @@ function assertNever(_x) {
 }
 function assert(_3) {}
 function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k3, _3]) => numericValues.indexOf(+k3) === -1).map(([_3, v]) => v);
+  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries).filter(([k3, _3]) => numericValues.indexOf(+k3) === -1).map(([_3, v2]) => v2);
   return values;
 }
 function joinValues(array, separator = "|") {
@@ -10646,9 +10767,9 @@ function defineLazy(object, key, getter) {
       }
       return value;
     },
-    set(v) {
+    set(v2) {
       Object.defineProperty(object, key, {
-        value: v
+        value: v2
       });
     },
     configurable: true
@@ -12254,10 +12375,10 @@ var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
       v7: 7,
       v8: 8
     };
-    const v = versionMap[def.version];
-    if (v === undefined)
+    const v2 = versionMap[def.version];
+    if (v2 === undefined)
       throw new Error(`Invalid UUID version: "${def.version}"`);
-    def.pattern ?? (def.pattern = uuid(v));
+    def.pattern ?? (def.pattern = uuid(v2));
   } else
     def.pattern ?? (def.pattern = uuid());
   $ZodStringFormat.init(inst, def);
@@ -12818,8 +12939,8 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
       const field = shape[key]._zod;
       if (field.values) {
         propValues[key] ?? (propValues[key] = new Set);
-        for (const v of field.values)
-          propValues[key].add(v);
+        for (const v2 of field.values)
+          propValues[key].add(v2);
       }
     }
     return propValues;
@@ -13008,10 +13129,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       const pv = option._zod.propValues;
       if (!pv || Object.keys(pv).length === 0)
         throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
-      for (const [k3, v] of Object.entries(pv)) {
+      for (const [k3, v2] of Object.entries(pv)) {
         if (!propValues[k3])
           propValues[k3] = new Set;
-        for (const val of v) {
+        for (const val of v2) {
           propValues[k3].add(val);
         }
       }
@@ -13025,11 +13146,11 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       const values = o2._zod.propValues?.[def.discriminator];
       if (!values || values.size === 0)
         throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o2)}"`);
-      for (const v of values) {
-        if (map2.has(v)) {
-          throw new Error(`Duplicate discriminator value "${String(v)}"`);
+      for (const v2 of values) {
+        if (map2.has(v2)) {
+          throw new Error(`Duplicate discriminator value "${String(v2)}"`);
         }
-        map2.set(v, o2);
+        map2.set(v2, o2);
       }
     }
     return map2;
@@ -13565,8 +13686,8 @@ var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
 var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "values", () => {
-    const v = def.innerType._zod.values;
-    return v ? new Set([...v].filter((x2) => x2 !== undefined)) : undefined;
+    const v2 = def.innerType._zod.values;
+    return v2 ? new Set([...v2].filter((x2) => x2 !== undefined)) : undefined;
   });
   inst._zod.parse = (payload, ctx) => {
     const result = def.innerType._zod.run(payload, ctx);
@@ -20120,7 +20241,7 @@ function _set(Class2, valueType, params) {
   });
 }
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new Class2({
     type: "enum",
     entries,
@@ -20279,8 +20400,8 @@ function _stringbool(Classes, _params) {
   let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
   let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
   if (params.case !== "sensitive") {
-    truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
-    falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
+    truthyArray = truthyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
+    falsyArray = falsyArray.map((v2) => typeof v2 === "string" ? v2.toLowerCase() : v2);
   }
   const truthySet = new Set(truthyArray);
   const falsySet = new Set(falsyArray);
@@ -20542,11 +20663,11 @@ class JSONSchemaGenerator {
             }
             const allKeys = new Set(Object.keys(shape));
             const requiredKeys = new Set([...allKeys].filter((key) => {
-              const v = def.shape[key]._zod;
+              const v2 = def.shape[key]._zod;
               if (this.io === "input") {
-                return v.optin === undefined;
+                return v2.optin === undefined;
               } else {
-                return v.optout === undefined;
+                return v2.optout === undefined;
               }
             }));
             if (requiredKeys.size > 0) {
@@ -20664,9 +20785,9 @@ class JSONSchemaGenerator {
           case "enum": {
             const json2 = _json;
             const values = getEnumValues(def.entries);
-            if (values.every((v) => typeof v === "number"))
+            if (values.every((v2) => typeof v2 === "number"))
               json2.type = "number";
-            if (values.every((v) => typeof v === "string"))
+            if (values.every((v2) => typeof v2 === "string"))
               json2.type = "string";
             json2.enum = values;
             break;
@@ -20698,13 +20819,13 @@ class JSONSchemaGenerator {
                 json2.const = val;
               }
             } else {
-              if (vals.every((v) => typeof v === "number"))
+              if (vals.every((v2) => typeof v2 === "number"))
                 json2.type = "number";
-              if (vals.every((v) => typeof v === "string"))
+              if (vals.every((v2) => typeof v2 === "string"))
                 json2.type = "string";
-              if (vals.every((v) => typeof v === "boolean"))
+              if (vals.every((v2) => typeof v2 === "boolean"))
                 json2.type = "string";
-              if (vals.every((v) => v === null))
+              if (vals.every((v2) => v2 === null))
                 json2.type = "null";
               json2.enum = vals;
             }
@@ -21905,7 +22026,7 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new ZodEnum({
     type: "enum",
     entries,
@@ -23277,8 +23398,8 @@ function getMcpCheckDefinitions() {
 
 // src/cli/doctor/checks/version.ts
 function compareVersions2(current, latest) {
-  const parseVersion = (v) => {
-    const cleaned = v.replace(/^v/, "").split("-")[0];
+  const parseVersion = (v2) => {
+    const cleaned = v2.replace(/^v/, "").split("-")[0];
     return cleaned.split(".").map((n) => parseInt(n, 10) || 0);
   };
   const curr = parseVersion(current);
@@ -23402,7 +23523,7 @@ function getAllCheckDefinitions() {
 }
 
 // src/cli/doctor/formatter.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 function formatStatusSymbol(status) {
   switch (status) {
     case "pass":
@@ -23419,13 +23540,13 @@ function formatCheckResult(result, verbose) {
   const symbol2 = formatStatusSymbol(result.status);
   const colorFn = STATUS_COLORS[result.status];
   const name = colorFn(result.name);
-  const message = import_picocolors8.default.dim(result.message);
+  const message = import_picocolors9.default.dim(result.message);
   let line = `  ${symbol2} ${name}`;
   if (result.message) {
     line += ` ${SYMBOLS3.arrow} ${message}`;
   }
   if (verbose && result.details && result.details.length > 0) {
-    const detailLines = result.details.map((d3) => `      ${SYMBOLS3.bullet} ${import_picocolors8.default.dim(d3)}`).join(`
+    const detailLines = result.details.map((d3) => `      ${SYMBOLS3.bullet} ${import_picocolors9.default.dim(d3)}`).join(`
 `);
     line += `
 ` + detailLines;
@@ -23435,44 +23556,44 @@ function formatCheckResult(result, verbose) {
 function formatCategoryHeader(category) {
   const name = CATEGORY_NAMES[category] || category;
   return `
-${import_picocolors8.default.bold(import_picocolors8.default.white(name))}
-${import_picocolors8.default.dim("\u2500".repeat(40))}`;
+${import_picocolors9.default.bold(import_picocolors9.default.white(name))}
+${import_picocolors9.default.dim("\u2500".repeat(40))}`;
 }
 function formatSummary(summary) {
   const lines = [];
-  lines.push(import_picocolors8.default.bold(import_picocolors8.default.white("Summary")));
-  lines.push(import_picocolors8.default.dim("\u2500".repeat(40)));
+  lines.push(import_picocolors9.default.bold(import_picocolors9.default.white("Summary")));
+  lines.push(import_picocolors9.default.dim("\u2500".repeat(40)));
   lines.push("");
-  const passText = summary.passed > 0 ? import_picocolors8.default.green(`${summary.passed} passed`) : import_picocolors8.default.dim("0 passed");
-  const failText = summary.failed > 0 ? import_picocolors8.default.red(`${summary.failed} failed`) : import_picocolors8.default.dim("0 failed");
-  const warnText = summary.warnings > 0 ? import_picocolors8.default.yellow(`${summary.warnings} warnings`) : import_picocolors8.default.dim("0 warnings");
-  const skipText = summary.skipped > 0 ? import_picocolors8.default.dim(`${summary.skipped} skipped`) : "";
+  const passText = summary.passed > 0 ? import_picocolors9.default.green(`${summary.passed} passed`) : import_picocolors9.default.dim("0 passed");
+  const failText = summary.failed > 0 ? import_picocolors9.default.red(`${summary.failed} failed`) : import_picocolors9.default.dim("0 failed");
+  const warnText = summary.warnings > 0 ? import_picocolors9.default.yellow(`${summary.warnings} warnings`) : import_picocolors9.default.dim("0 warnings");
+  const skipText = summary.skipped > 0 ? import_picocolors9.default.dim(`${summary.skipped} skipped`) : "";
   const parts = [passText, failText, warnText];
   if (skipText)
     parts.push(skipText);
   lines.push(`  ${parts.join(", ")}`);
-  lines.push(`  ${import_picocolors8.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
+  lines.push(`  ${import_picocolors9.default.dim(`Total: ${summary.total} checks in ${summary.duration}ms`)}`);
   return lines.join(`
 `);
 }
 function formatHeader() {
   return `
-${import_picocolors8.default.bgMagenta(import_picocolors8.default.white(" oMoMoMoMo... Doctor "))}
+${import_picocolors9.default.bgMagenta(import_picocolors9.default.white(" oMoMoMoMo... Doctor "))}
 `;
 }
 function formatFooter(summary) {
   if (summary.failed > 0) {
     return `
-${SYMBOLS3.cross} ${import_picocolors8.default.red("Issues detected. Please review the errors above.")}
+${SYMBOLS3.cross} ${import_picocolors9.default.red("Issues detected. Please review the errors above.")}
 `;
   }
   if (summary.warnings > 0) {
     return `
-${SYMBOLS3.warn} ${import_picocolors8.default.yellow("All systems operational with warnings.")}
+${SYMBOLS3.warn} ${import_picocolors9.default.yellow("All systems operational with warnings.")}
 `;
   }
   return `
-${SYMBOLS3.check} ${import_picocolors8.default.green("All systems operational!")}
+${SYMBOLS3.check} ${import_picocolors9.default.green("All systems operational!")}
 `;
 }
 function formatJsonOutput2(result) {
@@ -23584,22 +23705,33 @@ var packageJson = await Promise.resolve().then(() => __toESM(require_package(),
 var VERSION = packageJson.version;
 var program2 = new Command;
 program2.name("oh-my-opencode").description("The ultimate OpenCode plugin - multi-model orchestration, LSP tools, and more").version(VERSION, "-v, --version", "Show version number");
-program2.command("install").description("Install and configure oh-my-opencode with interactive setup").option("--no-tui", "Run in non-interactive mode (requires all options)").option("--claude <value>", "Claude subscription: no, yes, max20").option("--chatgpt <value>", "ChatGPT subscription: no, yes").option("--gemini <value>", "Gemini integration: no, yes").option("--skip-auth", "Skip authentication setup hints").addHelpText("after", `
+program2.command("install").description("Install and configure oh-my-opencode with interactive setup").option("--no-tui", "Run in non-interactive mode (requires all options)").option("--claude <value>", "Claude subscription: no, yes, max20").option("--chatgpt <value>", "ChatGPT subscription: no, yes").option("--gemini <value>", "Gemini integration: no, yes").option("--memory <value>", "Memory provider: no, mem0-cloud, mem0-local, letta (default: no)").option("--memory-endpoint <url>", "Memory endpoint for self-hosted providers").option("--skip-auth", "Skip authentication setup hints").addHelpText("after", `
 Examples:
   $ bunx oh-my-opencode install
   $ bunx oh-my-opencode install --no-tui --claude=max20 --chatgpt=yes --gemini=yes
   $ bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no
+  $ bunx oh-my-opencode install --no-tui --claude=yes --chatgpt=yes --gemini=yes --memory=mem0-cloud
+  $ bunx oh-my-opencode install --no-tui --claude=yes --chatgpt=no --gemini=no --memory=mem0-local --memory-endpoint=http://localhost:8000/v1
+  $ bunx oh-my-opencode install --no-tui --claude=yes --chatgpt=yes --gemini=yes --memory=letta --memory-endpoint=http://localhost:8283
 
 Model Providers:
   Claude      Required for Sisyphus (main orchestrator) and Librarian agents
   ChatGPT     Powers the Oracle agent for debugging and architecture
   Gemini      Powers frontend, documentation, and multimodal agents
+
+Memory Providers:
+  mem0-cloud  Mem0 Cloud (mem0.ai) - requires MEM0_API_KEY env var
+  mem0-local  Self-hosted Mem0 - requires --memory-endpoint (default: http://localhost:8000/v1)
+  letta       Self-hosted Letta server - requires --memory-endpoint (default: http://localhost:8283)
+              See: https://docs.letta.com/guides/selfhosting/
 `).action(async (options) => {
   const args = {
     tui: options.tui !== false,
     claude: options.claude,
     chatgpt: options.chatgpt,
     gemini: options.gemini,
+    memory: options.memory,
+    memoryEndpoint: options.memoryEndpoint,
     skipAuth: options.skipAuth ?? false
   };
   const exitCode = await install(args);