@devness/useai-cli 0.4.4 → 0.4.6

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // ../shared/dist/constants/paths.js
 import { join } from "path";
@@ -20,6 +20,7 @@ var CONFIG_FILE = join(USEAI_DIR, "config.json");
 var SESSIONS_FILE = join(DATA_DIR, "sessions.json");
 var MILESTONES_FILE = join(DATA_DIR, "milestones.json");
 var DAEMON_PID_FILE = join(USEAI_DIR, "daemon.pid");
+var USEAI_HOOKS_DIR = join(USEAI_DIR, "hooks");
 var DAEMON_PORT = 19200;
 var DAEMON_LOG_FILE = join(USEAI_DIR, "daemon.log");
 var DAEMON_MCP_URL = `http://127.0.0.1:${DAEMON_PORT}/mcp`;
@@ -29,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.4.4";
+var VERSION = "0.4.6";
 
 // ../shared/dist/constants/defaults.js
 var DEFAULT_CONFIG = {
@@ -1078,41 +1079,41 @@ var ZodType = class {
   get description() {
     return this._def.description;
   }
-  _getType(input) {
-    return getParsedType(input.data);
+  _getType(input2) {
+    return getParsedType(input2.data);
   }
-  _getOrReturnCtx(input, ctx) {
+  _getOrReturnCtx(input2, ctx) {
     return ctx || {
-      common: input.parent.common,
-      data: input.data,
-      parsedType: getParsedType(input.data),
+      common: input2.parent.common,
+      data: input2.data,
+      parsedType: getParsedType(input2.data),
       schemaErrorMap: this._def.errorMap,
-      path: input.path,
-      parent: input.parent
+      path: input2.path,
+      parent: input2.parent
     };
   }
-  _processInputParams(input) {
+  _processInputParams(input2) {
     return {
       status: new ParseStatus(),
       ctx: {
-        common: input.parent.common,
-        data: input.data,
-        parsedType: getParsedType(input.data),
+        common: input2.parent.common,
+        data: input2.data,
+        parsedType: getParsedType(input2.data),
         schemaErrorMap: this._def.errorMap,
-        path: input.path,
-        parent: input.parent
+        path: input2.path,
+        parent: input2.parent
       }
     };
   }
-  _parseSync(input) {
-    const result = this._parse(input);
+  _parseSync(input2) {
+    const result = this._parse(input2);
     if (isAsync(result)) {
       throw new Error("Synchronous parse encountered promise.");
     }
     return result;
   }
-  _parseAsync(input) {
-    const result = this._parse(input);
+  _parseAsync(input2) {
+    const result = this._parse(input2);
     return Promise.resolve(result);
   }
   parse(data, params) {
@@ -1438,13 +1439,13 @@ function isValidCidr(ip, version) {
   return false;
 }
 var ZodString = class _ZodString extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = String(input.data);
+      input2.data = String(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.string,
@@ -1456,8 +1457,8 @@ var ZodString = class _ZodString extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.length < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -1469,8 +1470,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.length > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.length > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -1482,10 +1483,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "length") {
-        const tooBig = input.data.length > check.value;
-        const tooSmall = input.data.length < check.value;
+        const tooBig = input2.data.length > check.value;
+        const tooSmall = input2.data.length < check.value;
         if (tooBig || tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           if (tooBig) {
             addIssueToContext(ctx, {
               code: ZodIssueCode.too_big,
@@ -1508,8 +1509,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "email") {
-        if (!emailRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emailRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "email",
             code: ZodIssueCode.invalid_string,
@@ -1521,8 +1522,8 @@ var ZodString = class _ZodString extends ZodType {
         if (!emojiRegex) {
           emojiRegex = new RegExp(_emojiRegex, "u");
         }
-        if (!emojiRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!emojiRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "emoji",
             code: ZodIssueCode.invalid_string,
@@ -1531,8 +1532,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "uuid") {
-        if (!uuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!uuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "uuid",
             code: ZodIssueCode.invalid_string,
@@ -1541,8 +1542,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "nanoid") {
-        if (!nanoidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!nanoidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "nanoid",
             code: ZodIssueCode.invalid_string,
@@ -1551,8 +1552,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid") {
-        if (!cuidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid",
             code: ZodIssueCode.invalid_string,
@@ -1561,8 +1562,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cuid2") {
-        if (!cuid2Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!cuid2Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cuid2",
             code: ZodIssueCode.invalid_string,
@@ -1571,8 +1572,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ulid") {
-        if (!ulidRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!ulidRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ulid",
             code: ZodIssueCode.invalid_string,
@@ -1582,9 +1583,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "url") {
         try {
-          new URL(input.data);
+          new URL(input2.data);
         } catch {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "url",
             code: ZodIssueCode.invalid_string,
@@ -1594,9 +1595,9 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "regex") {
         check.regex.lastIndex = 0;
-        const testResult = check.regex.test(input.data);
+        const testResult = check.regex.test(input2.data);
         if (!testResult) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "regex",
             code: ZodIssueCode.invalid_string,
@@ -1605,10 +1606,10 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "trim") {
-        input.data = input.data.trim();
+        input2.data = input2.data.trim();
       } else if (check.kind === "includes") {
-        if (!input.data.includes(check.value, check.position)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.includes(check.value, check.position)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { includes: check.value, position: check.position },
@@ -1617,12 +1618,12 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "toLowerCase") {
-        input.data = input.data.toLowerCase();
+        input2.data = input2.data.toLowerCase();
       } else if (check.kind === "toUpperCase") {
-        input.data = input.data.toUpperCase();
+        input2.data = input2.data.toUpperCase();
       } else if (check.kind === "startsWith") {
-        if (!input.data.startsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.startsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { startsWith: check.value },
@@ -1631,8 +1632,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "endsWith") {
-        if (!input.data.endsWith(check.value)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!input2.data.endsWith(check.value)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: { endsWith: check.value },
@@ -1642,8 +1643,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "datetime") {
         const regex = datetimeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "datetime",
@@ -1653,8 +1654,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "date") {
         const regex = dateRegex;
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "date",
@@ -1664,8 +1665,8 @@ var ZodString = class _ZodString extends ZodType {
         }
       } else if (check.kind === "time") {
         const regex = timeRegex(check);
-        if (!regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
             validation: "time",
@@ -1674,8 +1675,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "duration") {
-        if (!durationRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!durationRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "duration",
             code: ZodIssueCode.invalid_string,
@@ -1684,8 +1685,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "ip") {
-        if (!isValidIP(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidIP(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "ip",
             code: ZodIssueCode.invalid_string,
@@ -1694,8 +1695,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "jwt") {
-        if (!isValidJWT(input.data, check.alg)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidJWT(input2.data, check.alg)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "jwt",
             code: ZodIssueCode.invalid_string,
@@ -1704,8 +1705,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "cidr") {
-        if (!isValidCidr(input.data, check.version)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!isValidCidr(input2.data, check.version)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "cidr",
             code: ZodIssueCode.invalid_string,
@@ -1714,8 +1715,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64") {
-        if (!base64Regex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64Regex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64",
             code: ZodIssueCode.invalid_string,
@@ -1724,8 +1725,8 @@ var ZodString = class _ZodString extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "base64url") {
-        if (!base64urlRegex.test(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!base64urlRegex.test(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             validation: "base64url",
             code: ZodIssueCode.invalid_string,
@@ -1737,7 +1738,7 @@ var ZodString = class _ZodString extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   _regex(regex, validation, message) {
     return this.refinement((data) => regex.test(data), {
@@ -1998,13 +1999,13 @@ var ZodNumber = class _ZodNumber extends ZodType {
     this.max = this.lte;
     this.step = this.multipleOf;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Number(input.data);
+      input2.data = Number(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.number) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.number,
@@ -2016,8 +2017,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(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!util.isInteger(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: "integer",
@@ -2027,9 +2028,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -2041,9 +2042,9 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             maximum: check.value,
@@ -2055,8 +2056,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (floatSafeRemainder(input.data, check.value) !== 0) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (floatSafeRemainder(input2.data, check.value) !== 0) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -2065,8 +2066,8 @@ var ZodNumber = class _ZodNumber extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "finite") {
-        if (!Number.isFinite(input.data)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (!Number.isFinite(input2.data)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_finite,
             message: check.message
@@ -2077,7 +2078,7 @@ var ZodNumber = class _ZodNumber extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
   gte(value, message) {
     return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -2229,25 +2230,25 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
     this.min = this.gte;
     this.max = this.lte;
   }
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
       try {
-        input.data = BigInt(input.data);
+        input2.data = BigInt(input2.data);
       } catch {
-        return this._getInvalidInput(input);
+        return this._getInvalidInput(input2);
       }
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.bigint) {
-      return this._getInvalidInput(input);
+      return this._getInvalidInput(input2);
     }
     let ctx = void 0;
     const status = new ParseStatus();
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+        const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
         if (tooSmall) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             type: "bigint",
@@ -2258,9 +2259,9 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+        const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
         if (tooBig) {
-          ctx = this._getOrReturnCtx(input, ctx);
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             type: "bigint",
@@ -2271,8 +2272,8 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "multipleOf") {
-        if (input.data % check.value !== BigInt(0)) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data % check.value !== BigInt(0)) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.not_multiple_of,
             multipleOf: check.value,
@@ -2284,10 +2285,10 @@ var ZodBigInt = class _ZodBigInt extends ZodType {
         util.assertNever(check);
       }
     }
-    return { status: status.value, value: input.data };
+    return { status: status.value, value: input2.data };
   }
-  _getInvalidInput(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _getInvalidInput(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.bigint,
@@ -2396,13 +2397,13 @@ ZodBigInt.create = (params) => {
   });
 };
 var ZodBoolean = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = Boolean(input.data);
+      input2.data = Boolean(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.boolean) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.boolean,
@@ -2410,7 +2411,7 @@ var ZodBoolean = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodBoolean.create = (params) => {
@@ -2421,13 +2422,13 @@ ZodBoolean.create = (params) => {
   });
 };
 var ZodDate = class _ZodDate extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     if (this._def.coerce) {
-      input.data = new Date(input.data);
+      input2.data = new Date(input2.data);
     }
-    const parsedType = this._getType(input);
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.date) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.date,
@@ -2435,8 +2436,8 @@ var ZodDate = class _ZodDate extends ZodType {
       });
       return INVALID;
     }
-    if (Number.isNaN(input.data.getTime())) {
-      const ctx2 = this._getOrReturnCtx(input);
+    if (Number.isNaN(input2.data.getTime())) {
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_date
       });
@@ -2446,8 +2447,8 @@ var ZodDate = class _ZodDate extends ZodType {
     let ctx = void 0;
     for (const check of this._def.checks) {
       if (check.kind === "min") {
-        if (input.data.getTime() < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() < check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             message: check.message,
@@ -2459,8 +2460,8 @@ var ZodDate = class _ZodDate extends ZodType {
           status.dirty();
         }
       } else if (check.kind === "max") {
-        if (input.data.getTime() > check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+        if (input2.data.getTime() > check.value) {
+          ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_big,
             message: check.message,
@@ -2477,7 +2478,7 @@ var ZodDate = class _ZodDate extends ZodType {
     }
     return {
       status: status.value,
-      value: new Date(input.data.getTime())
+      value: new Date(input2.data.getTime())
     };
   }
   _addCheck(check) {
@@ -2530,10 +2531,10 @@ ZodDate.create = (params) => {
   });
 };
 var ZodSymbol = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.symbol) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.symbol,
@@ -2541,7 +2542,7 @@ var ZodSymbol = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodSymbol.create = (params) => {
@@ -2551,10 +2552,10 @@ ZodSymbol.create = (params) => {
   });
 };
 var ZodUndefined = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.undefined,
@@ -2562,7 +2563,7 @@ var ZodUndefined = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodUndefined.create = (params) => {
@@ -2572,10 +2573,10 @@ ZodUndefined.create = (params) => {
   });
 };
 var ZodNull = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.null) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.null,
@@ -2583,7 +2584,7 @@ var ZodNull = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodNull.create = (params) => {
@@ -2597,8 +2598,8 @@ var ZodAny = class extends ZodType {
     super(...arguments);
     this._any = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodAny.create = (params) => {
@@ -2612,8 +2613,8 @@ var ZodUnknown = class extends ZodType {
     super(...arguments);
     this._unknown = true;
   }
-  _parse(input) {
-    return OK(input.data);
+  _parse(input2) {
+    return OK(input2.data);
   }
 };
 ZodUnknown.create = (params) => {
@@ -2623,8 +2624,8 @@ ZodUnknown.create = (params) => {
   });
 };
 var ZodNever = class extends ZodType {
-  _parse(input) {
-    const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    const ctx = this._getOrReturnCtx(input2);
     addIssueToContext(ctx, {
       code: ZodIssueCode.invalid_type,
       expected: ZodParsedType.never,
@@ -2640,10 +2641,10 @@ ZodNever.create = (params) => {
   });
 };
 var ZodVoid = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.undefined) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.void,
@@ -2651,7 +2652,7 @@ var ZodVoid = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
 };
 ZodVoid.create = (params) => {
@@ -2661,8 +2662,8 @@ ZodVoid.create = (params) => {
   });
 };
 var ZodArray = class _ZodArray extends ZodType {
-  _parse(input) {
-    const { ctx, status } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx, status } = this._processInputParams(input2);
     const def = this._def;
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
@@ -2802,10 +2803,10 @@ var ZodObject = class _ZodObject extends ZodType {
     this._cached = { shape, keys };
     return this._cached;
   }
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.object) {
-      const ctx2 = this._getOrReturnCtx(input);
+      const ctx2 = this._getOrReturnCtx(input2);
       addIssueToContext(ctx2, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.object,
@@ -2813,7 +2814,7 @@ var ZodObject = class _ZodObject extends ZodType {
       });
       return INVALID;
     }
-    const { status, ctx } = this._processInputParams(input);
+    const { status, ctx } = this._processInputParams(input2);
     const { shape, keys: shapeKeys } = this._getCached();
     const extraKeys = [];
     if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -3126,8 +3127,8 @@ ZodObject.lazycreate = (shape, params) => {
   });
 };
 var ZodUnion = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const options = this._def.options;
     function handleResults(results) {
       for (const result of results) {
@@ -3248,8 +3249,8 @@ var getDiscriminator = (type) => {
   }
 };
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3362,8 +3363,8 @@ function mergeValues(a, b) {
   }
 }
 var ZodIntersection = class extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const handleParsed = (parsedLeft, parsedRight) => {
       if (isAborted(parsedLeft) || isAborted(parsedRight)) {
         return INVALID;
@@ -3415,8 +3416,8 @@ ZodIntersection.create = (left, right, params) => {
   });
 };
 var ZodTuple = class _ZodTuple extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.array) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3488,8 +3489,8 @@ var ZodRecord = class _ZodRecord extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.object) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3541,8 +3542,8 @@ var ZodMap = class extends ZodType {
   get valueSchema() {
     return this._def.valueType;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.map) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3601,8 +3602,8 @@ ZodMap.create = (keyType, valueType, params) => {
   });
 };
 var ZodSet = class _ZodSet extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3690,8 +3691,8 @@ var ZodFunction = class _ZodFunction extends ZodType {
     super(...arguments);
     this.validate = this.implement;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.function) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3794,8 +3795,8 @@ var ZodLazy = class extends ZodType {
   get schema() {
     return this._def.getter();
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const lazySchema = this._def.getter();
     return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
@@ -3808,9 +3809,9 @@ ZodLazy.create = (getter, params) => {
   });
 };
 var ZodLiteral = class extends ZodType {
-  _parse(input) {
-    if (input.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (input2.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         received: ctx.data,
         code: ZodIssueCode.invalid_literal,
@@ -3818,7 +3819,7 @@ var ZodLiteral = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
   get value() {
     return this._def.value;
@@ -3839,9 +3840,9 @@ function createZodEnum(values, params) {
   });
 }
 var ZodEnum = class _ZodEnum extends ZodType {
-  _parse(input) {
-    if (typeof input.data !== "string") {
-      const ctx = this._getOrReturnCtx(input);
+  _parse(input2) {
+    if (typeof input2.data !== "string") {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         expected: util.joinValues(expectedValues),
@@ -3853,8 +3854,8 @@ var ZodEnum = class _ZodEnum extends ZodType {
     if (!this._cache) {
       this._cache = new Set(this._def.values);
     }
-    if (!this._cache.has(input.data)) {
-      const ctx = this._getOrReturnCtx(input);
+    if (!this._cache.has(input2.data)) {
+      const ctx = this._getOrReturnCtx(input2);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3863,7 +3864,7 @@ var ZodEnum = class _ZodEnum extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get options() {
     return this._def.values;
@@ -3904,9 +3905,9 @@ var ZodEnum = class _ZodEnum extends ZodType {
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
-  _parse(input) {
+  _parse(input2) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input);
+    const ctx = this._getOrReturnCtx(input2);
     if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
@@ -3919,7 +3920,7 @@ var ZodNativeEnum = class extends ZodType {
     if (!this._cache) {
       this._cache = new Set(util.getValidEnumValues(this._def.values));
     }
-    if (!this._cache.has(input.data)) {
+    if (!this._cache.has(input2.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3928,7 +3929,7 @@ var ZodNativeEnum = class extends ZodType {
       });
       return INVALID;
     }
-    return OK(input.data);
+    return OK(input2.data);
   }
   get enum() {
     return this._def.values;
@@ -3945,8 +3946,8 @@ var ZodPromise = class extends ZodType {
   unwrap() {
     return this._def.type;
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
@@ -3978,8 +3979,8 @@ var ZodEffects = class extends ZodType {
   sourceType() {
     return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
   }
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     const effect = this._def.effect || null;
     const checkCtx = {
       addIssue: (arg) => {
@@ -4111,12 +4112,12 @@ ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
   });
 };
 var ZodOptional = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.undefined) {
       return OK(void 0);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -4130,12 +4131,12 @@ ZodOptional.create = (type, params) => {
   });
 };
 var ZodNullable = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType === ZodParsedType.null) {
       return OK(null);
     }
-    return this._def.innerType._parse(input);
+    return this._def.innerType._parse(input2);
   }
   unwrap() {
     return this._def.innerType;
@@ -4149,8 +4150,8 @@ ZodNullable.create = (type, params) => {
   });
 };
 var ZodDefault = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     let data = ctx.data;
     if (ctx.parsedType === ZodParsedType.undefined) {
       data = this._def.defaultValue();
@@ -4174,8 +4175,8 @@ ZodDefault.create = (type, params) => {
   });
 };
 var ZodCatch = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const newCtx = {
       ...ctx,
       common: {
@@ -4227,10 +4228,10 @@ ZodCatch.create = (type, params) => {
   });
 };
 var ZodNaN = class extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
+  _parse(input2) {
+    const parsedType = this._getType(input2);
     if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
+      const ctx = this._getOrReturnCtx(input2);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
         expected: ZodParsedType.nan,
@@ -4238,7 +4239,7 @@ var ZodNaN = class extends ZodType {
       });
       return INVALID;
     }
-    return { status: "valid", value: input.data };
+    return { status: "valid", value: input2.data };
   }
 };
 ZodNaN.create = (params) => {
@@ -4249,8 +4250,8 @@ ZodNaN.create = (params) => {
 };
 var BRAND = /* @__PURE__ */ Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { ctx } = this._processInputParams(input2);
     const data = ctx.data;
     return this._def.type._parse({
       data,
@@ -4263,8 +4264,8 @@ var ZodBranded = class extends ZodType {
   }
 };
 var ZodPipeline = class _ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
+  _parse(input2) {
+    const { status, ctx } = this._processInputParams(input2);
     if (ctx.common.async) {
       const handleAsync = async () => {
         const inResult = await this._def.in._parseAsync({
@@ -4318,8 +4319,8 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
   }
 };
 var ZodReadonly = class extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
+  _parse(input2) {
+    const result = this._def.innerType._parse(input2);
     const freeze = (data) => {
       if (isValid(data)) {
         data.value = Object.freeze(data.value);
@@ -4875,11 +4876,126 @@ function isAutostartInstalled() {
   }
 }
 
+// ../shared/dist/hooks/claude-code.js
+import { existsSync as existsSync7, 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";
+var STOP_GUARD_PATH = join3(USEAI_HOOKS_DIR, "stop-guard.js");
+var CLAUDE_SETTINGS_PATH = join3(homedir3(), ".claude", "settings.json");
+var STOP_GUARD_SCRIPT = `#!/usr/bin/env node
+'use strict';
+const { readFileSync } = require('node:fs');
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const hook = JSON.parse(input);
+    if (hook.stop_hook_active) process.exit(0);
+    if (!hook.transcript_path) process.exit(0);
+    let transcript;
+    try { transcript = readFileSync(hook.transcript_path, 'utf-8'); } catch { process.exit(0); }
+    if (!transcript.includes('useai_session_start')) process.exit(0);
+    if (transcript.includes('useai_session_end')) process.exit(0);
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: 'Before ending, call useai_session_end with milestones (generic descriptions of accomplishments), languages used, and files_touched_count.'
+    }));
+  } catch { process.exit(0); }
+});
+`;
+function readSettings() {
+  if (!existsSync7(CLAUDE_SETTINGS_PATH))
+    return {};
+  try {
+    return JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  mkdirSync3(join3(homedir3(), ".claude"), { recursive: true });
+  writeFileSync3(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+}
+function installClaudeCodeHooks() {
+  mkdirSync3(USEAI_HOOKS_DIR, { recursive: true });
+  writeFileSync3(STOP_GUARD_PATH, STOP_GUARD_SCRIPT);
+  try {
+    chmodSync(STOP_GUARD_PATH, "755");
+  } catch {
+  }
+  const settings = readSettings();
+  const hooks = settings["hooks"] ?? {};
+  const stopCmd = `node "${STOP_GUARD_PATH}"`;
+  const sealCmd = `curl -sf -X POST http://127.0.0.1:${DAEMON_PORT}/api/seal-active --max-time 3 2>/dev/null || true`;
+  let changed = false;
+  if (!hooks["Stop"])
+    hooks["Stop"] = [];
+  const stopArr = hooks["Stop"];
+  const hasStop = stopArr.some((g) => {
+    const inner = g["hooks"];
+    return inner?.some((h) => h["command"]?.includes("stop-guard"));
+  });
+  if (!hasStop) {
+    stopArr.push({ hooks: [{ type: "command", command: stopCmd, timeout: 10 }] });
+    changed = true;
+  }
+  if (!hooks["SessionEnd"])
+    hooks["SessionEnd"] = [];
+  const endArr = hooks["SessionEnd"];
+  const hasEnd = endArr.some((g) => {
+    const inner = g["hooks"];
+    return inner?.some((h) => h["command"]?.includes("seal-active"));
+  });
+  if (!hasEnd) {
+    endArr.push({ hooks: [{ type: "command", command: sealCmd, timeout: 5 }] });
+    changed = true;
+  }
+  settings["hooks"] = hooks;
+  writeSettings(settings);
+  return changed;
+}
+function removeClaudeCodeHooks() {
+  if (existsSync7(CLAUDE_SETTINGS_PATH)) {
+    try {
+      const settings = readSettings();
+      const hooks = settings["hooks"];
+      if (hooks) {
+        if (hooks["Stop"]) {
+          hooks["Stop"] = hooks["Stop"].filter((g) => {
+            const inner = g["hooks"];
+            return !inner?.some((h) => h["command"]?.includes("stop-guard"));
+          });
+          if (hooks["Stop"].length === 0)
+            delete hooks["Stop"];
+        }
+        if (hooks["SessionEnd"]) {
+          hooks["SessionEnd"] = hooks["SessionEnd"].filter((g) => {
+            const inner = g["hooks"];
+            return !inner?.some((h) => h["command"]?.includes("seal-active"));
+          });
+          if (hooks["SessionEnd"].length === 0)
+            delete hooks["SessionEnd"];
+        }
+        if (Object.keys(hooks).length === 0)
+          delete settings["hooks"];
+      }
+      writeSettings(settings);
+    } catch {
+    }
+  }
+  try {
+    if (existsSync7(STOP_GUARD_PATH))
+      unlinkSync3(STOP_GUARD_PATH);
+  } catch {
+  }
+}
+
 // src/services/tools.ts
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync8, 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 { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var USEAI_INSTRUCTIONS_TEXT = [
@@ -4895,7 +5011,7 @@ var MCP_ENTRY = {
 };
 var MCP_HTTP_URL = DAEMON_MCP_URL;
 var MCP_HTTP_ENTRY = { type: "http", url: MCP_HTTP_URL };
-var home = homedir3();
+var home = homedir4();
 function installStandardHttp(configPath) {
   const config = readJsonFile(configPath);
   const servers = config["mcpServers"] ?? {};
@@ -4921,9 +5037,9 @@ function hasBinary(name) {
   }
 }
 function readJsonFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return JSON.parse(raw);
   } catch {
@@ -4931,8 +5047,8 @@ function readJsonFile(path) {
   }
 }
 function writeJsonFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(data, null, 2) + "\n");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, JSON.stringify(data, null, 2) + "\n");
 }
 function isConfiguredStandard(configPath) {
   const config = readJsonFile(configPath);
@@ -5013,9 +5129,9 @@ function removeZed(configPath) {
   }
 }
 function readTomlFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return parseToml(raw);
   } catch {
@@ -5023,8 +5139,8 @@ function readTomlFile(path) {
   }
 }
 function writeTomlFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, stringifyToml(data) + "\n");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, stringifyToml(data) + "\n");
 }
 function isConfiguredToml(configPath) {
   const config = readTomlFile(configPath);
@@ -5052,9 +5168,9 @@ function removeToml(configPath) {
   }
 }
 function readYamlFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return parseYaml(raw) ?? {};
   } catch {
@@ -5062,8 +5178,8 @@ function readYamlFile(path) {
   }
 }
 function writeYamlFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, stringifyYaml(data));
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, stringifyYaml(data));
 }
 function isConfiguredYaml(configPath) {
   const config = readYamlFile(configPath);
@@ -5109,49 +5225,49 @@ var USEAI_INSTRUCTIONS_BLOCK = `${INSTRUCTIONS_START}
 ${USEAI_INSTRUCTIONS}
 ${INSTRUCTIONS_END}`;
 function hasInstructionsBlock(filePath) {
-  if (!existsSync7(filePath)) return false;
+  if (!existsSync8(filePath)) return false;
   try {
-    return readFileSync3(filePath, "utf-8").includes(INSTRUCTIONS_START);
+    return readFileSync4(filePath, "utf-8").includes(INSTRUCTIONS_START);
   } catch {
     return false;
   }
 }
 function injectInstructions(config) {
-  mkdirSync3(dirname2(config.path), { recursive: true });
+  mkdirSync4(dirname2(config.path), { recursive: true });
   if (config.method === "create") {
-    writeFileSync3(config.path, USEAI_INSTRUCTIONS + "\n");
+    writeFileSync4(config.path, USEAI_INSTRUCTIONS + "\n");
     return;
   }
   if (hasInstructionsBlock(config.path)) return;
   let existing = "";
-  if (existsSync7(config.path)) {
-    existing = readFileSync3(config.path, "utf-8");
+  if (existsSync8(config.path)) {
+    existing = readFileSync4(config.path, "utf-8");
   }
   const separator = existing && !existing.endsWith("\n") ? "\n\n" : existing ? "\n" : "";
-  writeFileSync3(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
+  writeFileSync4(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
 }
 function removeInstructions(config) {
   if (config.method === "create") {
-    if (existsSync7(config.path)) {
+    if (existsSync8(config.path)) {
       try {
-        unlinkSync3(config.path);
+        unlinkSync4(config.path);
       } catch {
       }
     }
     return;
   }
-  if (!existsSync7(config.path)) return;
+  if (!existsSync8(config.path)) return;
   try {
-    const content = readFileSync3(config.path, "utf-8");
+    const content = readFileSync4(config.path, "utf-8");
     const escaped = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regex = new RegExp(
       `\\n?${escaped(INSTRUCTIONS_START)}[\\s\\S]*?${escaped(INSTRUCTIONS_END)}\\n?`
     );
     const cleaned = content.replace(regex, "").trim();
     if (cleaned) {
-      writeFileSync3(config.path, cleaned + "\n");
+      writeFileSync4(config.path, cleaned + "\n");
     } else {
-      unlinkSync3(config.path);
+      unlinkSync4(config.path);
     }
   } catch {
   }
@@ -5195,7 +5311,7 @@ function createTool(def) {
     getManualHint: () => def.instructions ? null : def.manualHint ?? null
   };
 }
-var appSupport = join3(home, "Library", "Application Support");
+var appSupport = join4(home, "Library", "Application Support");
 function matchesTool(tool, query) {
   const q = query.toLowerCase().replace(/[\s-_]+/g, "");
   const id = tool.id.toLowerCase().replace(/[\s-_]+/g, "");
@@ -5222,17 +5338,17 @@ var AI_TOOLS = [
     id: "claude-code",
     name: "Claude Code",
     configFormat: "standard",
-    configPath: join3(home, ".claude.json"),
-    detect: () => hasBinary("claude") || existsSync7(join3(home, ".claude.json")),
-    instructions: { method: "append", path: join3(home, ".claude", "CLAUDE.md") },
+    configPath: join4(home, ".claude.json"),
+    detect: () => hasBinary("claude") || existsSync8(join4(home, ".claude.json")),
+    instructions: { method: "append", path: join4(home, ".claude", "CLAUDE.md") },
     supportsUrl: true
   }),
   createTool({
     id: "cursor",
     name: "Cursor",
     configFormat: "standard",
-    configPath: join3(home, ".cursor", "mcp.json"),
-    detect: () => existsSync7(join3(home, ".cursor")),
+    configPath: join4(home, ".cursor", "mcp.json"),
+    detect: () => existsSync8(join4(home, ".cursor")),
     manualHint: "Open Cursor Settings \u2192 Rules \u2192 User Rules and paste the instructions below.",
     supportsUrl: true
   }),
@@ -5240,51 +5356,51 @@ var AI_TOOLS = [
     id: "windsurf",
     name: "Windsurf",
     configFormat: "standard",
-    configPath: join3(home, ".codeium", "windsurf", "mcp_config.json"),
-    detect: () => existsSync7(join3(home, ".codeium", "windsurf")),
-    instructions: { method: "append", path: join3(home, ".codeium", "windsurf", "memories", "global_rules.md") },
+    configPath: join4(home, ".codeium", "windsurf", "mcp_config.json"),
+    detect: () => existsSync8(join4(home, ".codeium", "windsurf")),
+    instructions: { method: "append", path: join4(home, ".codeium", "windsurf", "memories", "global_rules.md") },
     supportsUrl: true
   }),
   createTool({
     id: "vscode",
     name: "VS Code",
     configFormat: "vscode",
-    configPath: join3(appSupport, "Code", "User", "mcp.json"),
-    detect: () => existsSync7(join3(appSupport, "Code")),
-    instructions: { method: "create", path: join3(appSupport, "Code", "User", "prompts", "useai.instructions.md") },
+    configPath: join4(appSupport, "Code", "User", "mcp.json"),
+    detect: () => existsSync8(join4(appSupport, "Code")),
+    instructions: { method: "create", path: join4(appSupport, "Code", "User", "prompts", "useai.instructions.md") },
     supportsUrl: true
   }),
   createTool({
     id: "vscode-insiders",
     name: "VS Code Insiders",
     configFormat: "vscode",
-    configPath: join3(appSupport, "Code - Insiders", "User", "mcp.json"),
-    detect: () => existsSync7(join3(appSupport, "Code - Insiders")),
-    instructions: { method: "create", path: join3(appSupport, "Code - Insiders", "User", "prompts", "useai.instructions.md") },
+    configPath: join4(appSupport, "Code - Insiders", "User", "mcp.json"),
+    detect: () => existsSync8(join4(appSupport, "Code - Insiders")),
+    instructions: { method: "create", path: join4(appSupport, "Code - Insiders", "User", "prompts", "useai.instructions.md") },
     supportsUrl: true
   }),
   createTool({
     id: "gemini-cli",
     name: "Gemini CLI",
     configFormat: "standard",
-    configPath: join3(home, ".gemini", "settings.json"),
+    configPath: join4(home, ".gemini", "settings.json"),
     detect: () => hasBinary("gemini"),
-    instructions: { method: "append", path: join3(home, ".gemini", "GEMINI.md") },
+    instructions: { method: "append", path: join4(home, ".gemini", "GEMINI.md") },
     supportsUrl: true
   }),
   createTool({
     id: "zed",
     name: "Zed",
     configFormat: "zed",
-    configPath: join3(appSupport, "Zed", "settings.json"),
-    detect: () => existsSync7(join3(appSupport, "Zed")),
+    configPath: join4(appSupport, "Zed", "settings.json"),
+    detect: () => existsSync8(join4(appSupport, "Zed")),
     manualHint: "Open Rules Library (\u2318\u2325L) \u2192 click + \u2192 paste the instructions below."
   }),
   createTool({
     id: "cline",
     name: "Cline",
     configFormat: "standard",
-    configPath: join3(
+    configPath: join4(
       appSupport,
       "Code",
       "User",
@@ -5293,17 +5409,17 @@ var AI_TOOLS = [
       "settings",
       "cline_mcp_settings.json"
     ),
-    detect: () => existsSync7(
-      join3(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
+    detect: () => existsSync8(
+      join4(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
     ),
-    instructions: { method: "create", path: join3(home, "Documents", "Cline", "Rules", "useai.md") },
+    instructions: { method: "create", path: join4(home, "Documents", "Cline", "Rules", "useai.md") },
     supportsUrl: true
   }),
   createTool({
     id: "roo-code",
     name: "Roo Code",
     configFormat: "standard",
-    configPath: join3(
+    configPath: join4(
       appSupport,
       "Code",
       "User",
@@ -5312,59 +5428,59 @@ var AI_TOOLS = [
       "settings",
       "cline_mcp_settings.json"
     ),
-    detect: () => existsSync7(
-      join3(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
+    detect: () => existsSync8(
+      join4(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
     ),
-    instructions: { method: "create", path: join3(home, ".roo", "rules", "useai.md") },
+    instructions: { method: "create", path: join4(home, ".roo", "rules", "useai.md") },
     supportsUrl: true
   }),
   createTool({
     id: "amazon-q-cli",
     name: "Amazon Q CLI",
     configFormat: "standard",
-    configPath: join3(home, ".aws", "amazonq", "mcp.json"),
-    detect: () => hasBinary("q") || existsSync7(join3(home, ".aws", "amazonq")),
+    configPath: join4(home, ".aws", "amazonq", "mcp.json"),
+    detect: () => hasBinary("q") || existsSync8(join4(home, ".aws", "amazonq")),
     manualHint: "Create .amazonq/rules/useai.md in your project root with the instructions below."
   }),
   createTool({
     id: "amazon-q-ide",
     name: "Amazon Q IDE",
     configFormat: "standard",
-    configPath: join3(home, ".aws", "amazonq", "default.json"),
-    detect: () => existsSync7(join3(home, ".amazonq")) || existsSync7(join3(home, ".aws", "amazonq")),
+    configPath: join4(home, ".aws", "amazonq", "default.json"),
+    detect: () => existsSync8(join4(home, ".amazonq")) || existsSync8(join4(home, ".aws", "amazonq")),
     manualHint: "Create .amazonq/rules/useai.md in your project root with the instructions below."
   }),
   createTool({
     id: "codex",
     name: "Codex",
     configFormat: "toml",
-    configPath: join3(home, ".codex", "config.toml"),
-    detect: () => hasBinary("codex") || existsSync7(join3(home, ".codex")) || existsSync7("/Applications/Codex.app"),
-    instructions: { method: "append", path: join3(home, ".codex", "AGENTS.md") }
+    configPath: join4(home, ".codex", "config.toml"),
+    detect: () => hasBinary("codex") || existsSync8(join4(home, ".codex")) || existsSync8("/Applications/Codex.app"),
+    instructions: { method: "append", path: join4(home, ".codex", "AGENTS.md") }
   }),
   createTool({
     id: "goose",
     name: "Goose",
     configFormat: "yaml",
-    configPath: join3(home, ".config", "goose", "config.yaml"),
-    detect: () => existsSync7(join3(home, ".config", "goose")),
-    instructions: { method: "append", path: join3(home, ".config", "goose", ".goosehints") }
+    configPath: join4(home, ".config", "goose", "config.yaml"),
+    detect: () => existsSync8(join4(home, ".config", "goose")),
+    instructions: { method: "append", path: join4(home, ".config", "goose", ".goosehints") }
   }),
   createTool({
     id: "opencode",
     name: "OpenCode",
     configFormat: "standard",
-    configPath: join3(home, ".config", "opencode", "opencode.json"),
-    detect: () => hasBinary("opencode") || existsSync7(join3(home, ".config", "opencode")),
-    instructions: { method: "append", path: join3(home, ".config", "opencode", "AGENTS.md") },
+    configPath: join4(home, ".config", "opencode", "opencode.json"),
+    detect: () => hasBinary("opencode") || existsSync8(join4(home, ".config", "opencode")),
+    instructions: { method: "append", path: join4(home, ".config", "opencode", "AGENTS.md") },
     supportsUrl: true
   }),
   createTool({
     id: "junie",
     name: "Junie",
     configFormat: "standard",
-    configPath: join3(home, ".junie", "mcp", "mcp.json"),
-    detect: () => existsSync7(join3(home, ".junie")),
+    configPath: join4(home, ".junie", "mcp", "mcp.json"),
+    detect: () => existsSync8(join4(home, ".junie")),
     manualHint: "Add the instructions below to .junie/guidelines.md in your project root."
   })
 ];
@@ -5458,6 +5574,14 @@ async function daemonInstallFlow(tools, explicit) {
       console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
     }
   }
+  try {
+    const hooksInstalled = installClaudeCodeHooks();
+    if (hooksInstalled) {
+      console.log(success("\u2713 Claude Code hooks installed (Stop + SessionEnd)"));
+    }
+  } catch {
+    console.log(chalk6.yellow("  \u26A0 Could not install Claude Code hooks"));
+  }
   showManualHints(targetTools);
   const mode = useDaemon ? "daemon mode" : "stdio mode";
   console.log(`
@@ -5632,6 +5756,11 @@ async function fullRemoveFlow(tools, autoYes, explicit) {
       }
     }
   }
+  try {
+    removeClaudeCodeHooks();
+    console.log(success("\u2713 Claude Code hooks removed"));
+  } catch {
+  }
   console.log();
   try {
     await killDaemon();
@@ -5815,8 +5944,145 @@ var serveCommand = new Command9("serve").description("Open the local UseAI dashb
   process.on("SIGTERM", shutdown);
 });
 
+// src/commands/login.ts
+import { Command as Command10 } from "commander";
+import chalk9 from "chalk";
+import { input } from "@inquirer/prompts";
+var API_URL = "https://api.useai.dev";
+async function apiCall(endpoint, body) {
+  const res = await fetch(`${API_URL}${endpoint}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(data.message ?? `Request failed (${res.status})`);
+  }
+  return data;
+}
+var loginCommand = new Command10("login").description("Login to useai.dev").action(async () => {
+  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."));
+      return;
+    }
+    const email = await input({
+      message: "Email:",
+      validate: (v) => v.includes("@") || "Please enter a valid email"
+    });
+    console.log(chalk9.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."));
+        return;
+      }
+      throw err;
+    }
+    console.log(chalk9.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({
+        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 (code.toLowerCase() === "resend") {
+        console.log(chalk9.dim("  Resending code..."));
+        try {
+          await apiCall("/api/auth/send-otp", { email });
+          console.log(chalk9.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."));
+            continue;
+          }
+          throw err;
+        }
+      }
+      try {
+        const result = await apiCall("/api/auth/verify-otp", { email, code });
+        if (result?.token) {
+          updateConfig({
+            auth: {
+              token: result.token,
+              user: {
+                id: result.user.id,
+                email: result.user.email,
+                username: result.user.username
+              }
+            }
+          });
+          console.log("");
+          console.log(chalk9.green(`  \u2713 Logged in as ${chalk9.bold(result.user.email)}`));
+          if (result.user.username) {
+            console.log(chalk9.dim(`    username: ${result.user.username}`));
+          }
+          console.log("");
+          console.log(chalk9.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..."));
+          await apiCall("/api/auth/send-otp", { email });
+          console.log(chalk9.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..."));
+          await apiCall("/api/auth/send-otp", { email });
+          console.log(chalk9.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.`));
+        } else {
+          console.log(chalk9.red("  Too many invalid attempts. Please try again later."));
+          return;
+        }
+      }
+    }
+    if (!success2) {
+      console.log(chalk9.red("  Login failed. Please try again."));
+    }
+  } catch (err) {
+    if (err.name === "ExitPromptError" || err.message?.includes("force closed")) {
+      console.log("");
+      console.log(chalk9.dim("  Cancelled."));
+      return;
+    }
+    console.log(chalk9.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."));
+    return;
+  }
+  const email = config.auth.user.email;
+  updateConfig({ auth: void 0 });
+  console.log(chalk9.green(`  \u2713 Logged out from ${email}`));
+});
+
 // src/index.ts
-var program = new Command10();
+var program = new Command11();
 program.name("useai").description("useai.dev \u2014 Track your AI-assisted development workflow").version(VERSION);
 program.addCommand(statsCommand);
 program.addCommand(statusCommand);
@@ -5827,4 +6093,6 @@ program.addCommand(purgeCommand);
 program.addCommand(mcpCommand);
 program.addCommand(daemonCommand);
 program.addCommand(serveCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
 program.parse();