@devness/useai-cli 0.8.5 → 0.8.7

package/dist/index.js

@@ -30,7 +30,7 @@ var SYSTEMD_SERVICE_PATH = join(homedir(), ".config", "systemd", "user", "useai-
 var WINDOWS_STARTUP_SCRIPT_PATH = join(process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "useai-daemon.vbs");
 
 // ../shared/dist/constants/version.js
-var VERSION = "0.8.5";
+var VERSION = "0.8.7";
 
 // ../shared/dist/constants/defaults.js
 var DEFAULT_CAPTURE_CONFIG = {
@@ -158,7 +158,7 @@ var KNOWN_CLIENTS = Object.keys(TOOL_COLORS);
 
 // src/commands/stats.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
+import pc2 from "picocolors";
 
 // ../shared/dist/utils/fs.js
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
@@ -291,24 +291,29 @@ function calculateStreak(sessions) {
 }
 
 // src/utils/display.ts
-import chalk from "chalk";
-function header(text) {
-  return chalk.bold.cyan(`
-  ${text}
-  ${"\u2500".repeat(text.length)}`);
+import pc from "picocolors";
+import { homedir as homedir2 } from "os";
+function header(text2) {
+  return pc.bold(pc.cyan(`
+  ${text2}
+  ${"\u2500".repeat(text2.length)}`));
 }
 function table(rows) {
   const maxLabel = Math.max(...rows.map(([label]) => label.length));
-  return rows.map(([label, value]) => `  ${chalk.dim(label.padEnd(maxLabel))}  ${value}`).join("\n");
+  return rows.map(([label, value]) => `  ${pc.dim(label.padEnd(maxLabel))}  ${value}`).join("\n");
+}
+function success(text2) {
+  return pc.green(`  ${text2}`);
 }
-function success(text) {
-  return chalk.green(`  ${text}`);
+function error(text2) {
+  return pc.red(`  ${text2}`);
 }
-function error(text) {
-  return chalk.red(`  ${text}`);
+function info(text2) {
+  return pc.dim(`  ${text2}`);
 }
-function info(text) {
-  return chalk.dim(`  ${text}`);
+function shortenPath(p3) {
+  const home2 = homedir2();
+  return home2 && p3.startsWith(home2) ? "~" + p3.slice(home2.length) : p3;
 }
 
 // src/commands/stats.ts
@@ -321,9 +326,9 @@ var statsCommand = new Command("stats").description("Show aggregated AI developm
   console.log(header("AI Development Stats"));
   console.log(
     table([
-      ["Total time", chalk2.bold(formatDuration(Math.round(stats.totalHours * 3600)))],
-      ["Sessions", chalk2.bold(String(stats.totalSessions))],
-      ["Current streak", chalk2.bold(`${stats.currentStreak} day${stats.currentStreak !== 1 ? "s" : ""}`)]
+      ["Total time", pc2.bold(formatDuration(Math.round(stats.totalHours * 3600)))],
+      ["Sessions", pc2.bold(String(stats.totalSessions))],
+      ["Current streak", pc2.bold(`${stats.currentStreak} day${stats.currentStreak !== 1 ? "s" : ""}`)]
     ])
   );
   const clientEntries = Object.entries(stats.byClient).sort((a, b) => b[1] - a[1]);
@@ -353,7 +358,7 @@ var statsCommand = new Command("stats").description("Show aggregated AI developm
 // src/commands/status.ts
 import { Command as Command2 } from "commander";
 import { existsSync as existsSync2, statSync, readdirSync } from "fs";
-import chalk3 from "chalk";
+import pc3 from "picocolors";
 
 // src/services/config.service.ts
 function getConfig() {
@@ -405,23 +410,23 @@ var statusCommand = new Command2("status").description("Full transparency dashbo
   console.log(header("useai Status"));
   console.log(
     table([
-      ["Sessions recorded", chalk3.bold(String(sessions.length))],
-      ["Total tracked time", chalk3.bold(formatDuration(totalSeconds))],
-      ["Milestones", chalk3.bold(`${unpublished} unpublished, ${published} published`)],
-      ["Local storage", chalk3.bold(formatBytes(storageSize))],
-      ["Data directory", chalk3.dim(DATA_DIR)]
+      ["Sessions recorded", pc3.bold(String(sessions.length))],
+      ["Total tracked time", pc3.bold(formatDuration(totalSeconds))],
+      ["Milestones", pc3.bold(`${unpublished} unpublished, ${published} published`)],
+      ["Local storage", pc3.bold(formatBytes(storageSize))],
+      ["Data directory", pc3.dim(DATA_DIR)]
     ])
   );
   console.log(header("Settings"));
   console.log(
     table([
-      ["Milestone tracking", config.capture.milestones ? chalk3.green("on") : chalk3.red("off")],
-      ["Prompt capture", config.capture.prompt ? chalk3.green("on") : chalk3.red("off")],
+      ["Milestone tracking", config.capture.milestones ? pc3.green("on") : pc3.red("off")],
+      ["Prompt capture", config.capture.prompt ? pc3.green("on") : pc3.red("off")],
       ["Eval reasons", config.capture.evaluation_reasons],
-      ["Cloud sync", config.sync.enabled ? chalk3.green("on") : chalk3.red("off")],
+      ["Cloud sync", config.sync.enabled ? pc3.green("on") : pc3.red("off")],
       ["Sync interval", `${config.sync.interval_hours}h`],
-      ["Last sync", config.last_sync_at ?? chalk3.dim("never")],
-      ["Logged in", config.auth ? chalk3.green(config.auth.user.email) : chalk3.dim("no")]
+      ["Last sync", config.last_sync_at ?? pc3.dim("never")],
+      ["Logged in", config.auth ? pc3.green(config.auth.user.email) : pc3.dim("no")]
     ])
   );
   console.log(header("Privacy"));
@@ -436,7 +441,7 @@ var statusCommand = new Command2("status").description("Full transparency dashbo
 
 // src/commands/milestones.ts
 import { Command as Command3 } from "commander";
-import chalk4 from "chalk";
+import pc4 from "picocolors";
 var milestonesCommand = new Command3("milestones").description("List local milestones").option("-v, --verbose", "Show full milestone details").action((opts) => {
   const milestones = readJson(MILESTONES_FILE, []);
   if (milestones.length === 0) {
@@ -445,11 +450,11 @@ var milestonesCommand = new Command3("milestones").description("List local miles
   }
   console.log(header(`Milestones (${milestones.length})`));
   for (const m of milestones) {
-    const status = m.published ? chalk4.green("published") : chalk4.yellow("local");
+    const status = m.published ? pc4.green("published") : pc4.yellow("local");
     const displayTitle = m.private_title ?? m.title;
     console.log(
       `
-  ${chalk4.bold(displayTitle)}  ${status}`
+  ${pc4.bold(displayTitle)}  ${status}`
     );
     console.log(
       table([
@@ -461,11 +466,11 @@ var milestonesCommand = new Command3("milestones").description("List local miles
     );
     if (opts.verbose) {
       const verboseRows = [
-        ["ID", chalk4.dim(m.id)],
-        ["Session", chalk4.dim(m.session_id)],
+        ["ID", pc4.dim(m.id)],
+        ["Session", pc4.dim(m.session_id)],
         ["Client", m.client],
         ["Languages", m.languages.join(", ") || "none"],
-        ["Chain hash", chalk4.dim(m.chain_hash.slice(0, 16) + "...")],
+        ["Chain hash", pc4.dim(m.chain_hash.slice(0, 16) + "...")],
         ["Published at", m.published_at ?? "n/a"]
       ];
       if (m.private_title) {
@@ -479,7 +484,7 @@ var milestonesCommand = new Command3("milestones").description("List local miles
 
 // src/commands/config.ts
 import { Command as Command4 } from "commander";
-import chalk5 from "chalk";
+import pc5 from "picocolors";
 
 // ../shared/dist/crypto/keystore.js
 import { generateKeyPairSync, randomBytes, createCipheriv, createDecipheriv, createPrivateKey } from "crypto";
@@ -1153,41 +1158,41 @@ var ZodType = class {
   get description() {
     return this._def.description;
   }
-  _getType(input2) {
-    return getParsedType(input2.data);
+  _getType(input) {
+    return getParsedType(input.data);
   }
-  _getOrReturnCtx(input2, ctx) {
+  _getOrReturnCtx(input, ctx) {
     return ctx || {
-      common: input2.parent.common,
-      data: input2.data,
-      parsedType: getParsedType(input2.data),
+      common: input.parent.common,
+      data: input.data,
+      parsedType: getParsedType(input.data),
       schemaErrorMap: this._def.errorMap,
-      path: input2.path,
-      parent: input2.parent
+      path: input.path,
+      parent: input.parent
     };
   }
-  _processInputParams(input2) {
+  _processInputParams(input) {
     return {
       status: new ParseStatus(),
       ctx: {
-        common: input2.parent.common,
-        data: input2.data,
-        parsedType: getParsedType(input2.data),
+        common: input.parent.common,
+        data: input.data,
+        parsedType: getParsedType(input.data),
         schemaErrorMap: this._def.errorMap,
-        path: input2.path,
-        parent: input2.parent
+        path: input.path,
+        parent: input.parent
       }
     };
   }
-  _parseSync(input2) {
-    const result = this._parse(input2);
+  _parseSync(input) {
+    const result = this._parse(input);
     if (isAsync(result)) {
       throw new Error("Synchronous parse encountered promise.");
     }
     return result;
   }
-  _parseAsync(input2) {
-    const result = this._parse(input2);
+  _parseAsync(input) {
+    const result = this._parse(input);
     return Promise.resolve(result);
   }
   parse(data, params) {
@@ -1513,13 +1518,13 @@ function isValidCidr(ip, version) {
   return false;
 }
 var ZodString = class _ZodString extends ZodType {
-  _parse(input2) {
+  _parse(input) {
     if (this._def.coerce) {
-      input2.data = String(input2.data);
+      input.data = String(input.data);
     }
-    const parsedType = this._getType(input2);
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input2);
+      const ctx2 = this._getOrReturnCtx(input);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
@@ -1531,8 +1536,8 @@ var ZodString = class _ZodString extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input2.data.length < check.value) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (input.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -1544,8 +1549,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input2.data.length > check.value) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (input.data.length > check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -1557,10 +1562,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "length") {
-        const tooBig = input2.data.length > check.value;
-        const tooSmall = input2.data.length < check.value;
+        const tooBig = input.data.length > check.value;
+        const tooSmall = input.data.length < check.value;
         if (tooBig || tooSmall) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           if (tooBig) {
             addIssueToContext(ctx, {
               code: ZodIssueCode.too_big,
@@ -1583,8 +1588,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "email") {
-        if (!emailRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!emailRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "email",
             code: ZodIssueCode.invalid_string,
@@ -1596,8 +1601,8 @@ var ZodString = class _ZodString extends ZodType {
         if (!emojiRegex) {
           emojiRegex = new RegExp(_emojiRegex, "u");
         }
-        if (!emojiRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!emojiRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "emoji",
             code: ZodIssueCode.invalid_string,
@@ -1606,8 +1611,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "uuid") {
-        if (!uuidRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!uuidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "uuid",
             code: ZodIssueCode.invalid_string,
@@ -1616,8 +1621,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "nanoid") {
-        if (!nanoidRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!nanoidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "nanoid",
             code: ZodIssueCode.invalid_string,
@@ -1626,8 +1631,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid") {
-        if (!cuidRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!cuidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "cuid",
             code: ZodIssueCode.invalid_string,
@@ -1636,8 +1641,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid2") {
-        if (!cuid2Regex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!cuid2Regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "cuid2",
             code: ZodIssueCode.invalid_string,
@@ -1646,8 +1651,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ulid") {
-        if (!ulidRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!ulidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "ulid",
             code: ZodIssueCode.invalid_string,
@@ -1657,9 +1662,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "url") {
         try {
-          new URL(input2.data);
+          new URL(input.data);
         } catch {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "url",
             code: ZodIssueCode.invalid_string,
@@ -1669,9 +1674,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "regex") {
         check.regex.lastIndex = 0;
-        const testResult = check.regex.test(input2.data);
+        const testResult = check.regex.test(input.data);
         if (!testResult) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "regex",
             code: ZodIssueCode.invalid_string,
@@ -1680,10 +1685,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "trim") {
-        input2.data = input2.data.trim();
+        input.data = input.data.trim();
       } else if (check.kind === "includes") {
-        if (!input2.data.includes(check.value, check.position)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!input.data.includes(check.value, check.position)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { includes: check.value, position: check.position },
@@ -1692,12 +1697,12 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "toLowerCase") {
-        input2.data = input2.data.toLowerCase();
+        input.data = input.data.toLowerCase();
       } else if (check.kind === "toUpperCase") {
-        input2.data = input2.data.toUpperCase();
+        input.data = input.data.toUpperCase();
       } else if (check.kind === "startsWith") {
-        if (!input2.data.startsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!input.data.startsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { startsWith: check.value },
@@ -1706,8 +1711,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "endsWith") {
-        if (!input2.data.endsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!input.data.endsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { endsWith: check.value },
@@ -1717,8 +1722,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "datetime") {
         const regex = datetimeRegex(check);
-        if (!regex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "datetime",
@@ -1728,8 +1733,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "date") {
         const regex = dateRegex;
-        if (!regex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "date",
@@ -1739,8 +1744,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "time") {
         const regex = timeRegex(check);
-        if (!regex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "time",
@@ -1749,8 +1754,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "duration") {
-        if (!durationRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!durationRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "duration",
             code: ZodIssueCode.invalid_string,
@@ -1759,8 +1764,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ip") {
-        if (!isValidIP(input2.data, check.version)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!isValidIP(input.data, check.version)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "ip",
             code: ZodIssueCode.invalid_string,
@@ -1769,8 +1774,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "jwt") {
-        if (!isValidJWT(input2.data, check.alg)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!isValidJWT(input.data, check.alg)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "jwt",
             code: ZodIssueCode.invalid_string,
@@ -1779,8 +1784,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cidr") {
-        if (!isValidCidr(input2.data, check.version)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!isValidCidr(input.data, check.version)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "cidr",
             code: ZodIssueCode.invalid_string,
@@ -1789,8 +1794,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64") {
-        if (!base64Regex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!base64Regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "base64",
             code: ZodIssueCode.invalid_string,
@@ -1799,8 +1804,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64url") {
-        if (!base64urlRegex.test(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!base64urlRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             validation: "base64url",
             code: ZodIssueCode.invalid_string,
@@ -1812,7 +1817,7 @@ var ZodString = class _ZodString extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input2.data };
+    return { status: status.value, value: input.data };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -2073,13 +2078,13 @@ var ZodNumber = class _ZodNumber extends ZodType {
     this.max = this.lte;
     this.step = this.multipleOf;
   }
-  _parse(input2) {
+  _parse(input) {
     if (this._def.coerce) {
-      input2.data = Number(input2.data);
+      input.data = Number(input.data);
     }
-    const parsedType = this._getType(input2);
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input2);
+      const ctx2 = this._getOrReturnCtx(input);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
@@ -2091,8 +2096,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "int") {
-        if (!util.isInteger(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!util.isInteger(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: "integer",
@@ -2102,9 +2107,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
+        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -2116,9 +2121,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
+        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -2130,8 +2135,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (floatSafeRemainder(input2.data, check.value) !== 0) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (floatSafeRemainder(input.data, check.value) !== 0) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -2140,8 +2145,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "finite") {
-        if (!Number.isFinite(input2.data)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (!Number.isFinite(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_finite,
             message: check.message
@@ -2152,7 +2157,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input2.data };
+    return { status: status.value, value: input.data };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -2304,25 +2309,25 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
     this.min = this.gte;
     this.max = this.lte;
   }
-  _parse(input2) {
+  _parse(input) {
     if (this._def.coerce) {
       try {
-        input2.data = BigInt(input2.data);
+        input.data = BigInt(input.data);
       } catch {
-        return this._getInvalidInput(input2);
+        return this._getInvalidInput(input);
       }
     }
-    const parsedType = this._getType(input2);
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.bigint) {
-      return this._getInvalidInput(input2);
+      return this._getInvalidInput(input);
     }
     let ctx = void 0;
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
+        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             type: "bigint",
@@ -2333,9 +2338,9 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
+        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             type: "bigint",
@@ -2346,8 +2351,8 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (input2.data % check.value !== BigInt(0)) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (input.data % check.value !== BigInt(0)) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -2359,10 +2364,10 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input2.data };
+    return { status: status.value, value: input.data };
   }
-  _getInvalidInput(input2) {
-    const ctx = this._getOrReturnCtx(input2);
+  _getInvalidInput(input) {
+    const ctx = this._getOrReturnCtx(input);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.bigint,
@@ -2471,13 +2476,13 @@ ZodBigInt.create = (params) => {
   });
 };
 var ZodBoolean = class extends ZodType {
-  _parse(input2) {
+  _parse(input) {
     if (this._def.coerce) {
-      input2.data = Boolean(input2.data);
+      input.data = Boolean(input.data);
     }
-    const parsedType = this._getType(input2);
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.boolean) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.boolean,
@@ -2485,7 +2490,7 @@ var ZodBoolean = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
 };
 ZodBoolean.create = (params) => {
@@ -2496,13 +2501,13 @@ ZodBoolean.create = (params) => {
   });
 };
 var ZodDate = class _ZodDate extends ZodType {
-  _parse(input2) {
+  _parse(input) {
     if (this._def.coerce) {
-      input2.data = new Date(input2.data);
+      input.data = new Date(input.data);
     }
-    const parsedType = this._getType(input2);
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input2);
+      const ctx2 = this._getOrReturnCtx(input);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
@@ -2510,8 +2515,8 @@ var ZodDate = class _ZodDate extends ZodType {
       });
       return INVALID;
     }
-    if (Number.isNaN(input2.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input2);
+    if (Number.isNaN(input.data.getTime())) {
+      const ctx2 = this._getOrReturnCtx(input);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_date
       });
@@ -2521,8 +2526,8 @@ var ZodDate = class _ZodDate extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input2.data.getTime() < check.value) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (input.data.getTime() < check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             message: check.message,
@@ -2534,8 +2539,8 @@ var ZodDate = class _ZodDate extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input2.data.getTime() > check.value) {
-          ctx = this._getOrReturnCtx(input2, ctx);
+        if (input.data.getTime() > check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             message: check.message,
@@ -2552,7 +2557,7 @@ var ZodDate = class _ZodDate extends ZodType {
     }
     return {
       status: status.value,
-      value: new Date(input2.data.getTime())
+      value: new Date(input.data.getTime())
     };
   }
   _addCheck(check) {
@@ -2605,10 +2610,10 @@ ZodDate.create = (params) => {
   });
 };
 var ZodSymbol = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.symbol) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.symbol,
@@ -2616,7 +2621,7 @@ var ZodSymbol = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
 };
 ZodSymbol.create = (params) => {
@@ -2626,10 +2631,10 @@ ZodSymbol.create = (params) => {
   });
 };
 var ZodUndefined = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.undefined,
@@ -2637,7 +2642,7 @@ var ZodUndefined = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
 };
 ZodUndefined.create = (params) => {
@@ -2647,10 +2652,10 @@ ZodUndefined.create = (params) => {
   });
 };
 var ZodNull = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.null) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.null,
@@ -2658,7 +2663,7 @@ var ZodNull = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
 };
 ZodNull.create = (params) => {
@@ -2672,8 +2677,8 @@ var ZodAny = class extends ZodType {
     super(...arguments);
     this._any = true;
   }
-  _parse(input2) {
-    return OK(input2.data);
+  _parse(input) {
+    return OK(input.data);
   }
 };
 ZodAny.create = (params) => {
@@ -2687,8 +2692,8 @@ var ZodUnknown = class extends ZodType {
     super(...arguments);
     this._unknown = true;
   }
-  _parse(input2) {
-    return OK(input2.data);
+  _parse(input) {
+    return OK(input.data);
   }
 };
 ZodUnknown.create = (params) => {
@@ -2698,8 +2703,8 @@ ZodUnknown.create = (params) => {
   });
 };
 var ZodNever = class extends ZodType {
-  _parse(input2) {
-    const ctx = this._getOrReturnCtx(input2);
+  _parse(input) {
+    const ctx = this._getOrReturnCtx(input);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.never,
@@ -2715,10 +2720,10 @@ ZodNever.create = (params) => {
   });
 };
 var ZodVoid = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.void,
@@ -2726,7 +2731,7 @@ var ZodVoid = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
 };
 ZodVoid.create = (params) => {
@@ -2736,8 +2741,8 @@ ZodVoid.create = (params) => {
   });
 };
 var ZodArray = class _ZodArray extends ZodType {
-  _parse(input2) {
-    const { ctx, status } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx, status } = this._processInputParams(input);
     const def = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
@@ -2877,10 +2882,10 @@ var ZodObject = class _ZodObject extends ZodType {
     this._cached = { shape, keys };
     return this._cached;
   }
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input2);
+      const ctx2 = this._getOrReturnCtx(input);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
@@ -2888,7 +2893,7 @@ var ZodObject = class _ZodObject extends ZodType {
       });
       return INVALID;
     }
-    const { status, ctx } = this._processInputParams(input2);
+    const { status, ctx } = this._processInputParams(input);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -3201,8 +3206,8 @@ ZodObject.lazycreate = (shape, params) => {
   });
 };
 var ZodUnion = class extends ZodType {
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     const options = this._def.options;
     function handleResults(results) {
       for (const result of results) {
@@ -3323,8 +3328,8 @@ var getDiscriminator = (type) => {
   }
 };
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3437,8 +3442,8 @@ function mergeValues(a, b) {
   }
 }
 var ZodIntersection = class extends ZodType {
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
@@ -3490,8 +3495,8 @@ ZodIntersection.create = (left, right, params) => {
   });
 };
 var ZodTuple = class _ZodTuple extends ZodType {
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3563,8 +3568,8 @@ var ZodRecord = class _ZodRecord extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3616,8 +3621,8 @@ var ZodMap = class extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.map) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3676,8 +3681,8 @@ ZodMap.create = (keyType, valueType, params) => {
   });
 };
 var ZodSet = class _ZodSet extends ZodType {
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3765,8 +3770,8 @@ var ZodFunction = class _ZodFunction extends ZodType {
     super(...arguments);
     this.validate = this.implement;
   }
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.function) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3869,8 +3874,8 @@ var ZodLazy = class extends ZodType {
   get schema() {
     return this._def.getter();
   }
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     const lazySchema = this._def.getter();
     return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
@@ -3883,9 +3888,9 @@ ZodLazy.create = (getter, params) => {
   });
 };
 var ZodLiteral = class extends ZodType {
-  _parse(input2) {
-    if (input2.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input2);
+  _parse(input) {
+    if (input.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         received: ctx.data,
         code: ZodIssueCode.invalid_literal,
@@ -3893,7 +3898,7 @@ var ZodLiteral = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input2.data };
+    return { status: "valid", value: input.data };
   }
   get value() {
     return this._def.value;
@@ -3914,9 +3919,9 @@ function createZodEnum(values, params) {
   });
 }
 var ZodEnum = class _ZodEnum extends ZodType {
-  _parse(input2) {
-    if (typeof input2.data !== "string") {
-      const ctx = this._getOrReturnCtx(input2);
+  _parse(input) {
+    if (typeof input.data !== "string") {
+      const ctx = this._getOrReturnCtx(input);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
@@ -3928,8 +3933,8 @@ var ZodEnum = class _ZodEnum extends ZodType {
     if (!this._cache) {
       this._cache = new Set(this._def.values);
     }
-    if (!this._cache.has(input2.data)) {
-      const ctx = this._getOrReturnCtx(input2);
+    if (!this._cache.has(input.data)) {
+      const ctx = this._getOrReturnCtx(input);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3938,7 +3943,7 @@ var ZodEnum = class _ZodEnum extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
   get options() {
     return this._def.values;
@@ -3979,9 +3984,9 @@ var ZodEnum = class _ZodEnum extends ZodType {
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
-  _parse(input2) {
+  _parse(input) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input2);
+    const ctx = this._getOrReturnCtx(input);
     if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
@@ -3994,7 +3999,7 @@ var ZodNativeEnum = class extends ZodType {
     if (!this._cache) {
       this._cache = new Set(util.getValidEnumValues(this._def.values));
     }
-    if (!this._cache.has(input2.data)) {
+    if (!this._cache.has(input.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -4003,7 +4008,7 @@ var ZodNativeEnum = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input2.data);
+    return OK(input.data);
   }
   get enum() {
     return this._def.values;
@@ -4020,8 +4025,8 @@ var ZodPromise = class extends ZodType {
   unwrap() {
     return this._def.type;
   }
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -4053,8 +4058,8 @@ var ZodEffects = class extends ZodType {
   sourceType() {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
@@ -4186,12 +4191,12 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
   });
 };
 var ZodOptional = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.undefined) {
       return OK(void 0);
     }
-    return this._def.innerType._parse(input2);
+    return this._def.innerType._parse(input);
   }
   unwrap() {
     return this._def.innerType;
@@ -4205,12 +4210,12 @@ ZodOptional.create = (type, params) => {
   });
 };
 var ZodNullable = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType === ZodParsedType.null) {
       return OK(null);
     }
-    return this._def.innerType._parse(input2);
+    return this._def.innerType._parse(input);
   }
   unwrap() {
     return this._def.innerType;
@@ -4224,8 +4229,8 @@ ZodNullable.create = (type, params) => {
   });
 };
 var ZodDefault = class extends ZodType {
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     let data = ctx.data;
     if (ctx.parsedType === ZodParsedType.undefined) {
       data = this._def.defaultValue();
@@ -4249,8 +4254,8 @@ ZodDefault.create = (type, params) => {
   });
 };
 var ZodCatch = class extends ZodType {
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     const newCtx = {
       ...ctx,
       common: {
@@ -4302,10 +4307,10 @@ ZodCatch.create = (type, params) => {
   });
 };
 var ZodNaN = class extends ZodType {
-  _parse(input2) {
-    const parsedType = this._getType(input2);
+  _parse(input) {
+    const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input2);
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.nan,
@@ -4313,7 +4318,7 @@ var ZodNaN = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input2.data };
+    return { status: "valid", value: input.data };
   }
 };
 ZodNaN.create = (params) => {
@@ -4324,8 +4329,8 @@ ZodNaN.create = (params) => {
 };
 var BRAND = /* @__PURE__ */ Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
-  _parse(input2) {
-    const { ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
     const data = ctx.data;
     return this._def.type._parse({
       data,
@@ -4338,8 +4343,8 @@ var ZodBranded = class extends ZodType {
   }
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input2) {
-    const { status, ctx } = this._processInputParams(input2);
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
     if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
@@ -4393,8 +4398,8 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
   }
 };
 var ZodReadonly = class extends ZodType {
-  _parse(input2) {
-    const result = this._def.innerType._parse(input2);
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
     const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
@@ -4415,9 +4420,9 @@ ZodReadonly.create = (type, params) => {
   });
 };
 function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
+  const p3 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p22 = typeof p3 === "string" ? { message: p3 } : p3;
+  return p22;
 }
 function custom(check, _params = {}, fatal) {
   if (check)
@@ -4680,14 +4685,14 @@ var publishPayloadSchema = external_exports.object({
 import { execSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 var isWindows = process.platform === "win32";
 var KNOWN_PATHS = isWindows ? [] : [
   "/usr/local/bin/npx",
   "/opt/homebrew/bin/npx",
-  join2(homedir2(), ".nvm", "current", "bin", "npx"),
-  join2(homedir2(), ".volta", "bin", "npx"),
-  join2(homedir2(), ".bun", "bin", "npx")
+  join2(homedir3(), ".nvm", "current", "bin", "npx"),
+  join2(homedir3(), ".volta", "bin", "npx"),
+  join2(homedir3(), ".bun", "bin", "npx")
 ];
 function resolveNpxPath() {
   const whichCmd = isWindows ? "where npx.cmd" : "which npx";
@@ -4723,14 +4728,14 @@ function resolveNpxPath() {
     } catch {
     }
   }
-  for (const p of KNOWN_PATHS) {
-    if (existsSync3(p))
-      return p;
+  for (const p3 of KNOWN_PATHS) {
+    if (existsSync3(p3))
+      return p3;
   }
   throw new Error("Could not find npx. Ensure Node.js is installed and npx is in your PATH.");
 }
 function buildNodePath() {
-  const home2 = homedir2();
+  const home2 = homedir3();
   const dirs = [
     "/usr/local/bin",
     "/opt/homebrew/bin",
@@ -4853,7 +4858,7 @@ async function killDaemon() {
   }
   const pids = findPidsByPort(port);
   if (pids.length > 0) {
-    await Promise.all(pids.map((p) => killPid(p)));
+    await Promise.all(pids.map((p3) => killPid(p3)));
   }
   try {
     if (existsSync4(DAEMON_PID_FILE))
@@ -5186,10 +5191,10 @@ async function fetchLatestVersion(packageName = PACKAGE_NAME) {
 // ../shared/dist/hooks/claude-code.js
 import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, chmodSync } from "fs";
 import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 var STOP_GUARD_PATH = join3(USEAI_HOOKS_DIR, "stop-guard.js");
 var PROMPT_GUARD_PATH = join3(USEAI_HOOKS_DIR, "prompt-guard.js");
-var CLAUDE_SETTINGS_PATH = join3(homedir3(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = join3(homedir4(), ".claude", "settings.json");
 var STOP_GUARD_SCRIPT = `#!/usr/bin/env node
 'use strict';
 const { readFileSync } = require('node:fs');
@@ -5248,7 +5253,7 @@ function readSettings() {
   }
 }
 function writeSettings(settings) {
-  mkdirSync3(join3(homedir3(), ".claude"), { recursive: true });
+  mkdirSync3(join3(homedir4(), ".claude"), { recursive: true });
   writeFileSync3(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
 }
 function installClaudeCodeHooks() {
@@ -5556,7 +5561,7 @@ function buildInstructionsText(frameworkId, opts) {
 import { execSync as execSync4 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4 } from "fs";
 import { dirname as dirname2, join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var USEAI_INSTRUCTIONS_TEXT = [
@@ -5571,7 +5576,7 @@ var MCP_ENTRY = {
 };
 var MCP_HTTP_URL = DAEMON_MCP_URL;
 var MCP_HTTP_ENTRY = { type: "http", url: MCP_HTTP_URL };
-var home = homedir4();
+var home = homedir5();
 function installStandardHttp(configPath) {
   const config = readJsonFile(configPath);
   const servers = config["mcpServers"] ?? {};
@@ -5967,7 +5972,7 @@ var AI_TOOLS = [
     name: "Claude Code",
     configFormat: "standard",
     configPath: join4(home, ".claude.json"),
-    detect: () => hasBinary("claude") || existsSync7(join4(home, ".claude.json")),
+    detect: () => existsSync7(join4(home, ".claude.json")) || hasBinary("claude"),
     instructions: { method: "append", path: join4(home, ".claude", "CLAUDE.md") },
     supportsUrl: true
   }),
@@ -6038,7 +6043,7 @@ var AI_TOOLS = [
     name: "Copilot CLI",
     configFormat: "standard",
     configPath: join4(home, ".copilot", "mcp-config.json"),
-    detect: () => hasBinary("copilot") || existsSync7(join4(home, ".copilot")),
+    detect: () => existsSync7(join4(home, ".copilot")) || hasBinary("copilot"),
     manualHint: "No global instructions file \u2014 add UseAI instructions to your project-level agent rules.",
     supportsUrl: true
   }),
@@ -6121,7 +6126,7 @@ var AI_TOOLS = [
     name: "Amazon Q CLI",
     configFormat: "standard",
     configPath: join4(home, ".aws", "amazonq", "mcp.json"),
-    detect: () => hasBinary("q") || existsSync7(join4(home, ".aws", "amazonq")),
+    detect: () => existsSync7(join4(home, ".aws", "amazonq")) || hasBinary("q"),
     manualHint: "Create .amazonq/rules/useai.md in your project root with the instructions below."
   }),
   createTool({
@@ -6137,7 +6142,7 @@ var AI_TOOLS = [
     name: "Codex",
     configFormat: "toml",
     configPath: join4(home, ".codex", "config.toml"),
-    detect: () => hasBinary("codex") || existsSync7(join4(home, ".codex")) || existsSync7("/Applications/Codex.app"),
+    detect: () => existsSync7(join4(home, ".codex")) || existsSync7("/Applications/Codex.app") || hasBinary("codex"),
     instructions: { method: "append", path: join4(home, ".codex", "AGENTS.md") },
     supportsUrl: true
   }),
@@ -6155,7 +6160,7 @@ var AI_TOOLS = [
     name: "OpenCode",
     configFormat: "standard",
     configPath: join4(home, ".config", "opencode", "opencode.json"),
-    detect: () => hasBinary("opencode") || existsSync7(join4(home, ".config", "opencode")),
+    detect: () => existsSync7(join4(home, ".config", "opencode")) || hasBinary("opencode"),
     instructions: { method: "append", path: join4(home, ".config", "opencode", "AGENTS.md") },
     supportsUrl: true
   }),
@@ -6164,7 +6169,7 @@ var AI_TOOLS = [
     name: "Crush",
     configFormat: "crush",
     configPath: join4(home, ".config", "crush", "crush.json"),
-    detect: () => hasBinary("crush") || existsSync7(join4(home, ".config", "crush")),
+    detect: () => existsSync7(join4(home, ".config", "crush")) || hasBinary("crush"),
     manualHint: "No global instructions file \u2014 add UseAI instructions to your project-level .crush.json.",
     supportsUrl: true
   }),
@@ -6228,7 +6233,7 @@ var configCommand = new Command4("config").description("View or update settings"
       console.log(error(`Unknown framework: ${opts.framework}. Valid: ${validIds.join(", ")}`));
     } else {
       updateConfig({ evaluation_framework: opts.framework });
-      console.log(success(`Evaluation framework set to ${chalk5.bold(opts.framework)}.`));
+      console.log(success(`Evaluation framework set to ${pc5.bold(opts.framework)}.`));
       const results = reinjectInstructions(opts.framework);
       if (results.length > 0) {
         for (const r of results) {
@@ -6243,14 +6248,14 @@ var configCommand = new Command4("config").description("View or update settings"
     console.log(header("Current Settings"));
     console.log(
       table([
-        ["Milestone tracking", config.capture.milestones ? chalk5.green("on") : chalk5.red("off")],
-        ["Prompt capture", config.capture.prompt ? chalk5.green("on") : chalk5.red("off")],
+        ["Milestone tracking", config.capture.milestones ? pc5.green("on") : pc5.red("off")],
+        ["Prompt capture", config.capture.prompt ? pc5.green("on") : pc5.red("off")],
         ["Eval reasons", config.capture.evaluation_reasons],
-        ["Cloud sync", config.sync.enabled ? chalk5.green("on") : chalk5.red("off")],
-        ["Eval framework", chalk5.cyan(config.evaluation_framework ?? "space")],
+        ["Cloud sync", config.sync.enabled ? pc5.green("on") : pc5.red("off")],
+        ["Eval framework", pc5.cyan(config.evaluation_framework ?? "space")],
         ["Sync interval", `${config.sync.interval_hours}h`],
-        ["Last sync", config.last_sync_at ?? chalk5.dim("never")],
-        ["Logged in", config.auth ? chalk5.green(config.auth.user.email) : chalk5.dim("no")]
+        ["Last sync", config.last_sync_at ?? pc5.dim("never")],
+        ["Logged in", config.auth ? pc5.green(config.auth.user.email) : pc5.dim("no")]
       ])
     );
     console.log("");
@@ -6304,188 +6309,195 @@ var purgeCommand = new Command6("purge").description("Delete ALL local useai dat
 
 // src/commands/setup.ts
 import { Command as Command7 } from "commander";
-import { checkbox } from "@inquirer/prompts";
-import chalk6 from "chalk";
-function shortenPath(p) {
-  const home2 = process.env["HOME"] ?? "";
-  return home2 && p.startsWith(home2) ? p.replace(home2, "~") : p;
-}
+import * as p from "@clack/prompts";
+import pc6 from "picocolors";
 function showManualHints(installedTools) {
   const hints = installedTools.map((t) => ({ name: t.name, hint: t.getManualHint() })).filter((h) => h.hint !== null);
   if (hints.length === 0) return;
-  console.log(chalk6.yellow(`
-  \u26A0 Manual setup needed for ${hints.length} tool${hints.length === 1 ? "" : "s"}:
-`));
-  for (const { name, hint } of hints) {
-    console.log(`  ${chalk6.bold(name)}: ${hint}`);
-  }
-  console.log();
-  for (const line of USEAI_INSTRUCTIONS_TEXT.split("\n")) {
-    console.log(`  ${line}`);
-  }
-  console.log();
+  const lines = hints.map(({ name, hint }) => `${pc6.bold(name)}: ${hint}`);
+  lines.push("", ...USEAI_INSTRUCTIONS_TEXT.split("\n"));
+  p.note(lines.join("\n"), `Manual setup needed for ${hints.length} tool${hints.length === 1 ? "" : "s"}`);
 }
 function showStatus(tools) {
-  console.log(header("AI Tool MCP Status"));
   const detected = tools.filter((t) => t.detect());
   if (detected.length === 0) {
-    console.log(chalk6.dim("  No supported AI tools detected on this system."));
-    console.log();
+    p.log.warn("No supported AI tools detected on this system.");
     return;
   }
-  const rows = [];
   const nameWidth = Math.max(...detected.map((t) => t.name.length));
-  const statusWidth = 16;
-  for (const tool of detected) {
+  const lines = detected.map((tool) => {
     const name = tool.name.padEnd(nameWidth);
+    const path = pc6.dim(shortenPath(tool.getConfigPath()));
     if (tool.isConfigured()) {
-      rows.push(
-        `  ${name}  ${chalk6.green("\u2713 Configured".padEnd(statusWidth))}  ${chalk6.dim(shortenPath(tool.getConfigPath()))}`
-      );
-    } else {
-      rows.push(
-        `  ${name}  ${chalk6.yellow("\u2717 Not set up".padEnd(statusWidth))}  ${chalk6.dim(shortenPath(tool.getConfigPath()))}`
-      );
+      return `${name}  ${pc6.green("\u2713 Configured")}    ${path}`;
+    }
+    return `${name}  ${pc6.yellow("\u2717 Not set up")}    ${path}`;
+  });
+  p.note(lines.join("\n"), "AI Tool MCP Status");
+}
+function configureToolAndCollect(tool, useDaemon) {
+  try {
+    if (useDaemon && tool.supportsUrl) {
+      tool.installHttp();
+      return { tool, ok: true, mode: "http" };
+    }
+    tool.install();
+    return { tool, ok: true, mode: "stdio" };
+  } catch (e) {
+    return { tool, ok: false, mode: "stdio", error: e.message };
+  }
+}
+function showGroupedResults(results) {
+  const httpOk = results.filter((r) => r.ok && r.mode === "http");
+  const stdioOk = results.filter((r) => r.ok && r.mode === "stdio");
+  const failed = results.filter((r) => !r.ok);
+  if (httpOk.length > 0) {
+    p.log.success(`HTTP (daemon): ${httpOk.map((r) => r.tool.name).join(", ")}`);
+  }
+  if (stdioOk.length > 0) {
+    p.log.success(`stdio: ${stdioOk.map((r) => r.tool.name).join(", ")}`);
+  }
+  if (failed.length > 0) {
+    for (const r of failed) {
+      p.log.error(`${r.tool.name} \u2014 ${r.error}`);
     }
   }
-  console.log(rows.join("\n"));
-  console.log();
 }
 async function daemonInstallFlow(tools, explicit) {
-  console.log(info("Ensuring UseAI daemon is running..."));
+  p.intro(pc6.bgCyan(pc6.black(" useai ")));
+  const s = p.spinner();
+  s.start("Starting UseAI daemon...");
   const daemonOk = await ensureDaemon();
   let useDaemon = true;
   if (daemonOk) {
-    console.log(success(`\u2713 Daemon running on port ${DAEMON_PORT}`));
+    s.stop(`Daemon running on port ${DAEMON_PORT}`);
   } else {
     useDaemon = false;
-    console.log(error("\u2717 Could not start daemon \u2014 falling back to stdio config"));
-    console.log(info(`(Run with --foreground to debug: npx @devness/useai@latest daemon --port ${DAEMON_PORT})`));
+    s.stop("Could not start daemon \u2014 falling back to stdio config");
+    p.note(
+      [
+        "Check if the port is in use:",
+        `  lsof -i :${DAEMON_PORT}`,
+        "",
+        "Run in foreground to debug:",
+        `  npx @devness/useai daemon --port ${DAEMON_PORT}`,
+        "",
+        "For containers/CI, use stdio mode:",
+        "  npx @devness/useai mcp --stdio"
+      ].join("\n"),
+      "Troubleshooting"
+    );
   }
   if (useDaemon) {
     const platform = detectPlatform();
     if (platform !== "unsupported") {
       try {
         installAutostart();
-        console.log(success(`\u2713 Auto-start service installed (${platform})`));
+        p.log.success(`Auto-start service installed (${platform})`);
       } catch {
-        console.log(chalk6.yellow(`  \u26A0 Could not install auto-start service`));
+        p.log.warn("Could not install auto-start service");
       }
     }
   }
   const targetTools = explicit ? tools : tools.filter((t) => t.detect());
   if (targetTools.length === 0) {
-    console.log(error("\n  No AI tools detected on this machine."));
+    p.log.error("No AI tools detected on this machine.");
+    p.outro("Setup complete.");
     return;
   }
-  let configuredCount = 0;
-  console.log();
+  const results = [];
   for (const tool of targetTools) {
-    try {
-      if (useDaemon && tool.supportsUrl) {
-        tool.installHttp();
-        console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim("HTTP (daemon)")}`));
-      } else if (useDaemon && !tool.supportsUrl) {
-        tool.install();
-        console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim("stdio (no URL support)")}`));
-      } else {
-        tool.install();
-        console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim("stdio")}`));
-      }
-      configuredCount++;
-    } catch (e) {
-      console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
-    }
+    results.push(configureToolAndCollect(tool, useDaemon));
   }
+  showGroupedResults(results);
   try {
     const hooksInstalled = installClaudeCodeHooks();
     if (hooksInstalled) {
-      console.log(success("\u2713 Claude Code hooks installed (UserPromptSubmit + Stop + SessionEnd)"));
+      p.log.success("Claude Code hooks installed (UserPromptSubmit + Stop + SessionEnd)");
     }
   } catch {
-    console.log(chalk6.yellow("  \u26A0 Could not install Claude Code hooks"));
+    p.log.warn("Could not install Claude Code hooks");
   }
   showManualHints(targetTools);
+  const configuredCount = results.filter((r) => r.ok).length;
   const mode = useDaemon ? "daemon mode" : "stdio mode";
-  console.log(`
-  Done! UseAI configured in ${chalk6.bold(String(configuredCount))} tool${configuredCount === 1 ? "" : "s"} (${mode}).
-`);
+  const dashboard = useDaemon ? `
+  Dashboard \u2192 ${pc6.cyan(`http://127.0.0.1:${DAEMON_PORT}/dashboard`)}` : "";
+  p.outro(`UseAI configured in ${pc6.bold(String(configuredCount))} tool${configuredCount === 1 ? "" : "s"} (${mode}).${dashboard}`);
 }
 async function stdioInstallFlow(tools, autoYes, explicit) {
+  p.intro(pc6.bgCyan(pc6.black(" useai ")));
   if (explicit) {
-    console.log();
+    const results2 = [];
     for (const tool of tools) {
-      try {
-        const wasConfigured = tool.isConfigured();
-        tool.install();
-        if (wasConfigured) {
-          console.log(success(`\u2713 ${tool.name.padEnd(18)}   ${chalk6.dim("(updated)")}`));
-        } else {
-          console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim(shortenPath(tool.getConfigPath()))}`));
-        }
-      } catch (err) {
-        console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${err.message}`));
-      }
+      results2.push(configureToolAndCollect(tool, false));
     }
+    showGroupedResults(results2);
     showManualHints(tools);
-    console.log();
+    p.outro("Setup complete.");
     return;
   }
-  console.log(info("Scanning for AI tools...\n"));
+  const s = p.spinner();
+  s.start("Scanning for AI tools...");
   const detected = tools.filter((t) => t.detect());
+  s.stop(`Found ${detected.length} AI tool${detected.length === 1 ? "" : "s"}`);
   if (detected.length === 0) {
-    console.log(error("No AI tools detected on this machine."));
+    p.log.error("No AI tools detected on this machine.");
+    p.outro("Setup complete.");
     return;
   }
   const alreadyConfigured = detected.filter((t) => t.isConfigured());
   const unconfigured = detected.filter((t) => !t.isConfigured());
-  console.log(`  Found ${chalk6.bold(String(detected.length))} AI tool${detected.length === 1 ? "" : "s"} on this machine:
-`);
-  for (const tool of alreadyConfigured) {
-    console.log(chalk6.green(`  \u2705 ${tool.name}`) + chalk6.dim("  (already configured)"));
-  }
-  for (const tool of unconfigured) {
-    console.log(chalk6.dim(`  \u2610  ${tool.name}`));
-  }
-  console.log();
+  const toolLines = [
+    ...alreadyConfigured.map((t) => `${pc6.green("\u2713")} ${t.name} ${pc6.dim("(already configured)")}`),
+    ...unconfigured.map((t) => `${pc6.dim("\u25CB")} ${t.name}`)
+  ];
+  p.note(toolLines.join("\n"), `${detected.length} AI tool${detected.length === 1 ? "" : "s"} detected`);
   if (unconfigured.length === 0) {
-    console.log(success("All detected tools are already configured."));
+    p.log.success("All detected tools are already configured.");
+    p.outro("Nothing to do.");
     return;
   }
   let toInstall;
   if (autoYes) {
     toInstall = unconfigured;
   } else {
-    let selected;
-    try {
-      selected = await checkbox({
-        message: "Select tools to configure:",
-        choices: unconfigured.map((t) => ({
-          name: t.name,
-          value: t.id,
-          checked: true
-        }))
-      });
-    } catch {
-      console.log("\n");
+    const selected = await p.multiselect({
+      message: `Select tools to configure ${pc6.dim("(space to toggle)")}`,
+      options: unconfigured.map((t) => ({
+        value: t.id,
+        label: t.name,
+        hint: shortenPath(t.getConfigPath())
+      })),
+      initialValues: unconfigured.map((t) => t.id),
+      required: true
+    });
+    if (p.isCancel(selected)) {
+      p.cancel("Setup cancelled.");
       return;
     }
     toInstall = unconfigured.filter((t) => selected.includes(t.id));
   }
   if (toInstall.length === 0) {
-    console.log(info("No tools selected."));
+    p.log.info("No tools selected.");
+    p.outro("Setup complete.");
     return;
   }
-  console.log(`
-  Configuring ${toInstall.length} tool${toInstall.length === 1 ? "" : "s"}...
-`);
+  p.note(
+    [
+      `Tools:  ${toInstall.map((t) => t.name).join(", ")}`,
+      `Mode:   stdio`
+    ].join("\n"),
+    "Installation Summary"
+  );
+  const shouldProceed = await p.confirm({ message: "Proceed with installation?" });
+  if (p.isCancel(shouldProceed) || !shouldProceed) {
+    p.cancel("Setup cancelled.");
+    return;
+  }
+  const results = [];
   for (const tool of toInstall) {
-    try {
-      tool.install();
-      console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim(shortenPath(tool.getConfigPath()))}`));
-    } catch (err) {
-      console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${err.message}`));
-    }
+    results.push(configureToolAndCollect(tool, false));
   }
   for (const tool of alreadyConfigured) {
     try {
@@ -6493,12 +6505,13 @@ async function stdioInstallFlow(tools, autoYes, explicit) {
     } catch {
     }
   }
+  showGroupedResults(results);
   showManualHints([...toInstall, ...alreadyConfigured]);
-  console.log(`
-  Done! UseAI MCP server configured in ${chalk6.bold(String(toInstall.length))} tool${toInstall.length === 1 ? "" : "s"}.
-`);
+  const configuredCount = results.filter((r) => r.ok).length;
+  p.outro(`UseAI configured in ${pc6.bold(String(configuredCount))} tool${configuredCount === 1 ? "" : "s"} (stdio mode).`);
 }
 async function fullRemoveFlow(tools, autoYes, explicit) {
+  p.intro(pc6.bgCyan(pc6.black(" useai ")));
   if (explicit) {
     const toRemove = tools.filter((t) => {
       try {
@@ -6515,17 +6528,14 @@ async function fullRemoveFlow(tools, autoYes, explicit) {
       }
     });
     for (const tool of notConfigured) {
-      console.log(info(`${tool.name} is not configured \u2014 skipping.`));
+      p.log.info(`${tool.name} is not configured \u2014 skipping.`);
     }
-    if (toRemove.length > 0) {
-      console.log();
-      for (const tool of toRemove) {
-        try {
-          tool.remove();
-          console.log(success(`\u2713 Removed from ${tool.name}`));
-        } catch (err) {
-          console.log(error(`\u2717 ${tool.name} \u2014 ${err.message}`));
-        }
+    for (const tool of toRemove) {
+      try {
+        tool.remove();
+        p.log.success(`Removed from ${tool.name}`);
+      } catch (err) {
+        p.log.error(`${tool.name} \u2014 ${err.message}`);
       }
     }
   } else {
@@ -6537,43 +6547,37 @@ async function fullRemoveFlow(tools, autoYes, explicit) {
       }
     });
     if (configured.length === 0) {
-      console.log(info("UseAI is not configured in any AI tools."));
+      p.log.info("UseAI is not configured in any AI tools.");
     } else {
-      console.log(`
-  Found UseAI configured in ${chalk6.bold(String(configured.length))} tool${configured.length === 1 ? "" : "s"}:
-`);
       let toRemove;
       if (autoYes) {
         toRemove = configured;
       } else {
-        let selected;
-        try {
-          selected = await checkbox({
-            message: "Select tools to remove UseAI from:",
-            choices: configured.map((t) => ({
-              name: t.name,
-              value: t.id,
-              checked: true
-            }))
-          });
-        } catch {
-          console.log("\n");
+        const selected = await p.multiselect({
+          message: `Select tools to remove UseAI from ${pc6.dim("(space to toggle)")}`,
+          options: configured.map((t) => ({
+            value: t.id,
+            label: t.name,
+            hint: shortenPath(t.getConfigPath())
+          })),
+          initialValues: configured.map((t) => t.id),
+          required: true
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Removal cancelled.");
           return;
         }
         toRemove = configured.filter((t) => selected.includes(t.id));
       }
       if (toRemove.length === 0) {
-        console.log(info("No tools selected."));
+        p.log.info("No tools selected.");
       } else {
-        console.log(`
-  Removing from ${toRemove.length} tool${toRemove.length === 1 ? "" : "s"}...
-`);
         for (const tool of toRemove) {
           try {
             tool.remove();
-            console.log(success(`\u2713 Removed from ${tool.name}`));
+            p.log.success(`Removed from ${tool.name}`);
           } catch (err) {
-            console.log(error(`\u2717 ${tool.name} \u2014 ${err.message}`));
+            p.log.error(`${tool.name} \u2014 ${err.message}`);
           }
         }
       }
@@ -6589,27 +6593,26 @@ async function fullRemoveFlow(tools, autoYes, explicit) {
   if (!anyRemaining) {
     try {
       removeClaudeCodeHooks();
-      console.log(success("\u2713 Claude Code hooks removed"));
+      p.log.success("Claude Code hooks removed");
     } catch {
     }
-    console.log();
     try {
       await killDaemon();
-      console.log(success("\u2713 Daemon stopped"));
+      p.log.success("Daemon stopped");
     } catch {
-      console.log(info("Daemon was not running"));
+      p.log.info("Daemon was not running");
     }
     if (isAutostartInstalled()) {
       try {
         removeAutostart();
-        console.log(success("\u2713 Auto-start service removed"));
+        p.log.success("Auto-start service removed");
       } catch {
-        console.log(error("\u2717 Failed to remove auto-start service"));
+        p.log.error("Failed to remove auto-start service");
       }
     }
-    console.log(info("\nDone! UseAI fully removed.\n"));
+    p.outro("UseAI fully removed.");
   } else {
-    console.log(info("\nDone! Other tools still configured \u2014 daemon and hooks kept running.\n"));
+    p.outro("Other tools still configured \u2014 daemon and hooks kept running.");
   }
 }
 var mcpCommand = new Command7("mcp").description("Configure UseAI MCP server in your AI tools").argument("[tools...]", "Specific tool names (e.g. codex cursor vscode)").option("--stdio", "Use stdio config (legacy mode for containers/CI)").option("--remove", "Remove UseAI from configured tools, stop daemon, remove auto-start").option("--status", "Show configuration status without modifying").option("-y, --yes", "Skip confirmation, auto-select all detected tools").action(async (toolNames, opts) => {
@@ -6618,8 +6621,8 @@ var mcpCommand = new Command7("mcp").description("Configure UseAI MCP server in
   if (explicit) {
     const { matched, unmatched } = resolveTools(toolNames);
     if (unmatched.length > 0) {
-      console.log(error(`Unknown tool${unmatched.length === 1 ? "" : "s"}: ${unmatched.join(", ")}`));
-      console.log(info(`Available: ${AI_TOOLS.map((t) => t.id).join(", ")}`));
+      p.log.error(`Unknown tool${unmatched.length === 1 ? "" : "s"}: ${unmatched.join(", ")}`);
+      p.log.info(`Available: ${AI_TOOLS.map((t) => t.id).join(", ")}`);
       return;
     }
     tools = matched;
@@ -6638,14 +6641,14 @@ var mcpCommand = new Command7("mcp").description("Configure UseAI MCP server in
 // src/commands/daemon.ts
 import { Command as Command8 } from "commander";
 import { spawn as spawn2 } from "child_process";
-import chalk7 from "chalk";
+import pc7 from "picocolors";
 var startCommand = new Command8("start").description("Start the UseAI daemon").option("-p, --port <port>", "Port to listen on", String(DAEMON_PORT)).option("--foreground", "Run in foreground (don't daemonize)").action(async (opts) => {
   const port = parseInt(opts.port, 10);
   const pid = readPidFile();
   if (pid && isProcessRunning(pid.pid)) {
     const health = await fetchDaemonHealth(pid.port);
     if (health) {
-      console.log(chalk7.yellow(`  Daemon already running (PID ${pid.pid}, port ${pid.port})`));
+      console.log(pc7.yellow(`  Daemon already running (PID ${pid.pid}, port ${pid.port})`));
       return;
     }
   }
@@ -6660,55 +6663,55 @@ var startCommand = new Command8("start").description("Start the UseAI daemon").o
     });
     return;
   }
-  console.log(chalk7.dim("  Starting daemon..."));
+  console.log(pc7.dim("  Starting daemon..."));
   const started = await ensureDaemon();
   if (started) {
     const newPid = readPidFile();
-    console.log(chalk7.green(`  \u2713 Daemon started (PID ${newPid?.pid ?? "unknown"}, port ${port})`));
+    console.log(pc7.green(`  \u2713 Daemon started (PID ${newPid?.pid ?? "unknown"}, port ${port})`));
   } else {
-    console.log(chalk7.red(`  \u2717 Daemon failed to start within 8 seconds`));
-    console.log(chalk7.dim(`    Try: useai daemon start --foreground`));
+    console.log(pc7.red(`  \u2717 Daemon failed to start within 8 seconds`));
+    console.log(pc7.dim(`    Try: useai daemon start --foreground`));
   }
 });
 var stopCommand = new Command8("stop").description("Stop the UseAI daemon").option("-p, --port <port>", "Port to stop daemon on", String(DAEMON_PORT)).action(async (opts) => {
   const port = parseInt(opts.port, 10);
   const pid = readPidFile();
   if (pid && isProcessRunning(pid.pid)) {
-    console.log(chalk7.dim(`  Stopping daemon (PID ${pid.pid})...`));
+    console.log(pc7.dim(`  Stopping daemon (PID ${pid.pid})...`));
     await killDaemon();
-    console.log(chalk7.green(`  \u2713 Daemon stopped`));
+    console.log(pc7.green(`  \u2713 Daemon stopped`));
     return;
   }
   const pids = findPidsByPort(port);
   if (pids.length > 0) {
-    console.log(chalk7.dim(`  Stopping daemon on port ${port} (PIDs: ${pids.join(", ")})...`));
+    console.log(pc7.dim(`  Stopping daemon on port ${port} (PIDs: ${pids.join(", ")})...`));
     await killDaemon();
-    console.log(chalk7.green(`  \u2713 Daemon stopped`));
+    console.log(pc7.green(`  \u2713 Daemon stopped`));
     return;
   }
-  console.log(chalk7.dim("  Daemon is not running"));
+  console.log(pc7.dim("  Daemon is not running"));
 });
 var statusCommand2 = new Command8("status").description("Show daemon status").action(async () => {
   const pid = readPidFile();
   if (!pid) {
-    console.log(chalk7.dim("  Daemon is not running"));
+    console.log(pc7.dim("  Daemon is not running"));
     return;
   }
   if (!isProcessRunning(pid.pid)) {
-    console.log(chalk7.dim("  Daemon is not running (stale PID file)"));
+    console.log(pc7.dim("  Daemon is not running (stale PID file)"));
     return;
   }
   const health = await fetchDaemonHealth(pid.port);
   if (!health) {
-    console.log(chalk7.yellow(`  Daemon process exists (PID ${pid.pid}) but health check failed`));
+    console.log(pc7.yellow(`  Daemon process exists (PID ${pid.pid}) but health check failed`));
     return;
   }
   const uptime = health["uptime_seconds"];
   const platform = detectPlatform();
-  const autostartStatus = isAutostartInstalled() ? chalk7.green("installed") + chalk7.dim(` (${platform})`) : chalk7.dim("not installed");
-  console.log(chalk7.bold.cyan("\n  UseAI Daemon"));
-  console.log(chalk7.bold.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log(`  Status:          ${chalk7.green("running")}`);
+  const autostartStatus = isAutostartInstalled() ? pc7.green("installed") + pc7.dim(` (${platform})`) : pc7.dim("not installed");
+  console.log(pc7.bold(pc7.cyan("\n  UseAI Daemon")));
+  console.log(pc7.bold(pc7.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")));
+  console.log(`  Status:          ${pc7.green("running")}`);
   console.log(`  PID:             ${pid.pid}`);
   console.log(`  Port:            ${pid.port}`);
   console.log(`  Version:         ${health["version"]}`);
@@ -6720,48 +6723,48 @@ var statusCommand2 = new Command8("status").description("Show daemon status").ac
 var autostartInstallCommand = new Command8("install").description("Install auto-start service (survives reboots)").action(() => {
   const platform = detectPlatform();
   if (platform === "unsupported") {
-    console.log(chalk7.red(`  \u2717 Auto-start is not supported on ${process.platform}`));
+    console.log(pc7.red(`  \u2717 Auto-start is not supported on ${process.platform}`));
     return;
   }
   try {
     installAutostart();
-    console.log(chalk7.green(`  \u2713 Auto-start installed (${platform})`));
+    console.log(pc7.green(`  \u2713 Auto-start installed (${platform})`));
   } catch (e) {
-    console.log(chalk7.red(`  \u2717 Failed to install auto-start: ${e.message}`));
+    console.log(pc7.red(`  \u2717 Failed to install auto-start: ${e.message}`));
   }
 });
 var autostartRemoveCommand = new Command8("remove").description("Remove auto-start service").action(() => {
   try {
     removeAutostart();
-    console.log(chalk7.green(`  \u2713 Auto-start removed`));
+    console.log(pc7.green(`  \u2713 Auto-start removed`));
   } catch (e) {
-    console.log(chalk7.red(`  \u2717 Failed to remove auto-start: ${e.message}`));
+    console.log(pc7.red(`  \u2717 Failed to remove auto-start: ${e.message}`));
   }
 });
 var autostartStatusCommand = new Command8("status").description("Check auto-start status").action(() => {
   const platform = detectPlatform();
   const installed = isAutostartInstalled();
   if (installed) {
-    console.log(chalk7.green(`  \u2713 Auto-start is installed (${platform})`));
+    console.log(pc7.green(`  \u2713 Auto-start is installed (${platform})`));
   } else {
-    console.log(chalk7.dim(`  Auto-start is not installed`));
+    console.log(pc7.dim(`  Auto-start is not installed`));
   }
 });
 var autostartRecoverCommand = new Command8("recover").description("Recover auto-start from disabled/failed state (after crash loops)").action(() => {
   const platform = detectPlatform();
   if (platform === "unsupported") {
-    console.log(chalk7.red(`  \u2717 Auto-start is not supported on ${process.platform}`));
+    console.log(pc7.red(`  \u2717 Auto-start is not supported on ${process.platform}`));
     return;
   }
   if (!isAutostartInstalled()) {
-    console.log(chalk7.yellow("  Auto-start is not installed. Run: useai daemon autostart install"));
+    console.log(pc7.yellow("  Auto-start is not installed. Run: useai daemon autostart install"));
     return;
   }
   const result = recoverAutostart();
   if (result.recovered) {
-    console.log(chalk7.green(`  \u2713 ${result.message}`));
+    console.log(pc7.green(`  \u2713 ${result.message}`));
   } else {
-    console.log(chalk7.yellow(`  ${result.message}`));
+    console.log(pc7.yellow(`  ${result.message}`));
   }
 });
 var autostartCommand = new Command8("autostart").description("Manage auto-start service").addCommand(autostartInstallCommand).addCommand(autostartRemoveCommand).addCommand(autostartStatusCommand).addCommand(autostartRecoverCommand);
@@ -6770,26 +6773,26 @@ var daemonCommand = new Command8("daemon").description("Manage the UseAI HTTP da
 // src/commands/serve.ts
 import { Command as Command9 } from "commander";
 import { exec } from "child_process";
-import chalk8 from "chalk";
+import pc8 from "picocolors";
 var serveCommand = new Command9("serve").description("Open the local UseAI dashboard").option("--open", "Open the dashboard in your default browser").action(async (opts) => {
   const url = `http://127.0.0.1:${DAEMON_PORT}/dashboard`;
-  console.log(chalk8.dim("  Ensuring daemon is running..."));
+  console.log(pc8.dim("  Ensuring daemon is running..."));
   const started = await ensureDaemon();
   if (!started) {
-    console.log(chalk8.red("  Failed to start daemon. Try: useai daemon start --foreground"));
+    console.log(pc8.red("  Failed to start daemon. Try: useai daemon start --foreground"));
     process.exit(1);
   }
-  console.log(chalk8.green(`  Dashboard running at ${chalk8.bold(url)}`));
+  console.log(pc8.green(`  Dashboard running at ${pc8.bold(url)}`));
   if (opts.open) {
     const cmd = process.platform === "darwin" ? "open" : "xdg-open";
     exec(`${cmd} ${url}`, (err) => {
       if (err) {
-        console.log(chalk8.yellow(`  Could not open browser: ${err.message}`));
-        console.log(chalk8.dim(`  Open manually: ${url}`));
+        console.log(pc8.yellow(`  Could not open browser: ${err.message}`));
+        console.log(pc8.dim(`  Open manually: ${url}`));
       }
     });
   }
-  console.log(chalk8.dim("  Press Ctrl+C to exit"));
+  console.log(pc8.dim("  Press Ctrl+C to exit"));
   const keepAlive = setInterval(() => {
   }, 6e4);
   const shutdown = () => {
@@ -6802,8 +6805,8 @@ var serveCommand = new Command9("serve").description("Open the local UseAI dashb
 
 // src/commands/login.ts
 import { Command as Command10 } from "commander";
-import chalk9 from "chalk";
-import { input } from "@inquirer/prompts";
+import * as p2 from "@clack/prompts";
+import pc9 from "picocolors";
 var API_URL = process.env.USEAI_API_URL || "https://api.useai.dev";
 async function apiCall(endpoint, body) {
   const res = await fetch(`${API_URL}${endpoint}`, {
@@ -6821,47 +6824,58 @@ var loginCommand = new Command10("login").description("Login to useai.dev").acti
   try {
     const config = getConfig();
     if (config.auth?.token) {
-      console.log(chalk9.dim(`  Already logged in as ${chalk9.bold(config.auth.user.email)}`));
-      console.log(chalk9.dim("  Run `useai logout` to switch accounts."));
+      console.log(pc9.dim(`  Already logged in as ${pc9.bold(config.auth.user.email)}`));
+      console.log(pc9.dim("  Run `useai logout` to switch accounts."));
       return;
     }
-    const email = await input({
+    const emailResult = await p2.text({
       message: "Email:",
-      validate: (v) => v.includes("@") || "Please enter a valid email"
+      validate: (v) => !v || !v.includes("@") ? "Please enter a valid email" : void 0
     });
-    console.log(chalk9.dim("  Sending verification code..."));
+    if (p2.isCancel(emailResult)) {
+      console.log(pc9.dim("\n  Cancelled."));
+      return;
+    }
+    const email = emailResult;
+    console.log(pc9.dim("  Sending verification code..."));
     try {
       await apiCall("/api/auth/send-otp", { email });
     } catch (err) {
       if (err.message.includes("rate") || err.message.includes("Too many")) {
-        console.log(chalk9.red("  Too many requests. Please wait a minute and try again."));
+        console.log(pc9.red("  Too many requests. Please wait a minute and try again."));
         return;
       }
       throw err;
     }
-    console.log(chalk9.green("  \u2713 Code sent to your email"));
+    console.log(pc9.green("  \u2713 Code sent to your email"));
     console.log("");
     let attempts = 0;
     const maxAttempts = 3;
     let success2 = false;
     while (attempts < maxAttempts && !success2) {
-      const code = await input({
+      const codeResult = await p2.text({
         message: 'Enter 6-digit code (or "resend"):',
         validate: (v) => {
-          if (v.toLowerCase() === "resend") return true;
-          return /^\d{6}$/.test(v) || 'Code must be 6 digits (or type "resend")';
+          if (!v) return "Code is required";
+          if (v.toLowerCase() === "resend") return void 0;
+          return /^\d{6}$/.test(v) ? void 0 : 'Code must be 6 digits (or type "resend")';
         }
       });
+      if (p2.isCancel(codeResult)) {
+        console.log(pc9.dim("\n  Cancelled."));
+        return;
+      }
+      const code = codeResult;
       if (code.toLowerCase() === "resend") {
-        console.log(chalk9.dim("  Resending code..."));
+        console.log(pc9.dim("  Resending code..."));
         try {
           await apiCall("/api/auth/send-otp", { email });
-          console.log(chalk9.green("  \u2713 New code sent"));
+          console.log(pc9.green("  \u2713 New code sent"));
           console.log("");
           continue;
         } catch (err) {
           if (err.message.includes("rate") || err.message.includes("Too many")) {
-            console.log(chalk9.yellow("  Please wait before requesting a new code."));
+            console.log(pc9.yellow("  Please wait before requesting a new code."));
             continue;
           }
           throw err;
@@ -6881,80 +6895,80 @@ var loginCommand = new Command10("login").description("Login to useai.dev").acti
             }
           });
           console.log("");
-          console.log(chalk9.green(`  \u2713 Logged in as ${chalk9.bold(result.user.email)}`));
+          console.log(pc9.green(`  \u2713 Logged in as ${pc9.bold(result.user.email)}`));
           if (result.user.username) {
-            console.log(chalk9.dim(`    username: ${result.user.username}`));
+            console.log(pc9.dim(`    username: ${result.user.username}`));
           }
           console.log("");
-          console.log(chalk9.dim("  Your sessions and milestones will sync to useai.dev"));
+          console.log(pc9.dim("  Your sessions and milestones will sync to useai.dev"));
           success2 = true;
         }
       } catch (err) {
         attempts++;
         if (err.message.includes("expired") || err.message.includes("No valid OTP")) {
-          console.log(chalk9.red("  Code expired. Sending a new one..."));
+          console.log(pc9.red("  Code expired. Sending a new one..."));
           await apiCall("/api/auth/send-otp", { email });
-          console.log(chalk9.green("  \u2713 New code sent"));
+          console.log(pc9.green("  \u2713 New code sent"));
           attempts = 0;
           continue;
         }
         if (err.message.includes("Too many attempts")) {
-          console.log(chalk9.red("  Too many attempts. Sending a new code..."));
+          console.log(pc9.red("  Too many attempts. Sending a new code..."));
           await apiCall("/api/auth/send-otp", { email });
-          console.log(chalk9.green("  \u2713 New code sent"));
+          console.log(pc9.green("  \u2713 New code sent"));
           attempts = 0;
           continue;
         }
         const remaining = maxAttempts - attempts;
         if (remaining > 0) {
-          console.log(chalk9.red(`  Invalid code. ${remaining} attempt(s) remaining.`));
+          console.log(pc9.red(`  Invalid code. ${remaining} attempt(s) remaining.`));
         } else {
-          console.log(chalk9.red("  Too many invalid attempts. Please try again later."));
+          console.log(pc9.red("  Too many invalid attempts. Please try again later."));
           return;
         }
       }
     }
     if (!success2) {
-      console.log(chalk9.red("  Login failed. Please try again."));
+      console.log(pc9.red("  Login failed. Please try again."));
     }
   } catch (err) {
     if (err.name === "ExitPromptError" || err.message?.includes("force closed")) {
       console.log("");
-      console.log(chalk9.dim("  Cancelled."));
+      console.log(pc9.dim("  Cancelled."));
       return;
     }
-    console.log(chalk9.red(`  Login failed: ${err.message}`));
+    console.log(pc9.red(`  Login failed: ${err.message}`));
   }
 });
 var logoutCommand = new Command10("logout").description("Logout from useai.dev").action(() => {
   const config = getConfig();
   if (!config.auth) {
-    console.log(chalk9.dim("  Not logged in."));
+    console.log(pc9.dim("  Not logged in."));
     return;
   }
   const email = config.auth.user.email;
   updateConfig({ auth: void 0 });
-  console.log(chalk9.green(`  \u2713 Logged out from ${email}`));
+  console.log(pc9.green(`  \u2713 Logged out from ${email}`));
 });
 
 // src/commands/update.ts
 import { Command as Command11 } from "commander";
-import chalk10 from "chalk";
+import pc10 from "picocolors";
 var updateCommand = new Command11("update").description("Update UseAI to the latest version (daemon + MCP configs)").action(async () => {
-  console.log(chalk10.dim("  Checking for updates..."));
+  console.log(pc10.dim("  Checking for updates..."));
   const latest = await fetchLatestVersion();
   if (!latest) {
-    console.log(chalk10.red("  \u2717 Could not reach npm registry"));
+    console.log(pc10.red("  \u2717 Could not reach npm registry"));
     return;
   }
   const health = await fetchDaemonHealth();
   const currentVersion = health?.["version"] ?? VERSION;
   if (currentVersion === latest) {
-    console.log(chalk10.green(`  \u2713 Already up to date (v${latest})`));
+    console.log(pc10.green(`  \u2713 Already up to date (v${latest})`));
     return;
   }
-  console.log(`  ${chalk10.dim("Current:")} v${currentVersion}`);
-  console.log(`  ${chalk10.dim("Latest:")}  v${latest}`);
+  console.log(`  ${pc10.dim("Current:")} v${currentVersion}`);
+  console.log(`  ${pc10.dim("Latest:")}  v${latest}`);
   console.log();
   const configuredTools = AI_TOOLS.filter((t) => {
     try {
@@ -6964,7 +6978,7 @@ var updateCommand = new Command11("update").description("Update UseAI to the lat
     }
   });
   if (configuredTools.length > 0) {
-    console.log(chalk10.dim("  Removing MCP configs from configured tools..."));
+    console.log(pc10.dim("  Removing MCP configs from configured tools..."));
     for (const tool of configuredTools) {
       try {
         tool.remove();
@@ -6975,20 +6989,20 @@ var updateCommand = new Command11("update").description("Update UseAI to the lat
     }
     console.log();
   }
-  console.log(chalk10.dim("  Stopping current daemon..."));
+  console.log(pc10.dim("  Stopping current daemon..."));
   await killDaemon();
-  console.log(chalk10.dim("  Starting updated daemon..."));
+  console.log(pc10.dim("  Starting updated daemon..."));
   const daemonOk = await ensureDaemon();
   if (!daemonOk) {
-    console.log(chalk10.red("  \u2717 Failed to start updated daemon"));
-    console.log(chalk10.dim("    Try running in foreground to debug:"));
-    console.log(chalk10.dim(`    npx -y --prefer-online @devness/useai@latest daemon --port ${DAEMON_PORT}`));
+    console.log(pc10.red("  \u2717 Failed to start updated daemon"));
+    console.log(pc10.dim("    Try running in foreground to debug:"));
+    console.log(pc10.dim(`    npx -y --prefer-online @devness/useai@latest daemon --port ${DAEMON_PORT}`));
     if (configuredTools.length > 0) {
-      console.log(chalk10.dim("\n  Reinstalling MCP configs (stdio fallback)..."));
+      console.log(pc10.dim("\n  Reinstalling MCP configs (stdio fallback)..."));
       for (const tool of configuredTools) {
         try {
           tool.install();
-          console.log(success(`  \u2713 ${tool.name} \u2192 ${chalk10.dim("stdio")}`));
+          console.log(success(`  \u2713 ${tool.name} \u2192 ${pc10.dim("stdio")}`));
         } catch {
           console.log(error(`  \u2717 ${tool.name}`));
         }
@@ -6998,18 +7012,18 @@ var updateCommand = new Command11("update").description("Update UseAI to the lat
   }
   const newHealth = await fetchDaemonHealth();
   const newVersion = newHealth?.["version"] ?? "unknown";
-  console.log(chalk10.green(`
+  console.log(pc10.green(`
   \u2713 Daemon updated: v${currentVersion} \u2192 v${newVersion}`));
   if (configuredTools.length > 0) {
-    console.log(chalk10.dim("\n  Reinstalling MCP configs..."));
+    console.log(pc10.dim("\n  Reinstalling MCP configs..."));
     for (const tool of configuredTools) {
       try {
         if (tool.supportsUrl) {
           tool.installHttp();
-          console.log(success(`  \u2713 ${tool.name} \u2192 ${chalk10.dim("HTTP (daemon)")}`));
+          console.log(success(`  \u2713 ${tool.name} \u2192 ${pc10.dim("HTTP (daemon)")}`));
         } else {
           tool.install();
-          console.log(success(`  \u2713 ${tool.name} \u2192 ${chalk10.dim("stdio")}`));
+          console.log(success(`  \u2713 ${tool.name} \u2192 ${pc10.dim("stdio")}`));
         }
       } catch {
         console.log(error(`  \u2717 ${tool.name}`));
@@ -7024,9 +7038,9 @@ var updateCommand = new Command11("update").description("Update UseAI to the lat
   } catch {
   }
   console.log(`
-  Done! UseAI updated to v${newVersion} in ${chalk10.bold(String(configuredTools.length))} tool${configuredTools.length === 1 ? "" : "s"}.
+  Done! UseAI updated to v${newVersion} in ${pc10.bold(String(configuredTools.length))} tool${configuredTools.length === 1 ? "" : "s"}.
 `);
-  console.log(chalk10.dim(`  Dashboard: http://127.0.0.1:${DAEMON_PORT}/dashboard`));
+  console.log(pc10.dim(`  Dashboard: http://127.0.0.1:${DAEMON_PORT}/dashboard`));
 });
 
 // src/index.ts