@meet-ai/cli 0.0.18 → 0.0.19

package/dist/index.js

@@ -519,7 +519,7 @@ var require_picocolors = __commonJS((exports, module) => {
 });
 
 // src/lib/output.ts
-var import_picocolors, ok = (msg) => console.log(import_picocolors.default.green(msg)), err = (msg) => console.error(import_picocolors.default.red(`error: ${msg}`));
+var import_picocolors, ok = (msg) => console.log(import_picocolors.default.green(msg)), err = (msg) => console.error(import_picocolors.default.red(`error: ${msg}`)), info = (msg) => console.log(import_picocolors.default.cyan(msg));
 var init_output = __esm(() => {
   import_picocolors = __toESM(require_picocolors(), 1);
 });
@@ -15703,10 +15703,10 @@ var init_command10 = __esm(() => {
 // ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.development.js
 var require_react_development = __commonJS((exports, module) => {
   (function() {
-    function defineDeprecationWarning(methodName, info) {
+    function defineDeprecationWarning(methodName, info2) {
       Object.defineProperty(Component.prototype, methodName, {
         get: function() {
-          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info2[0], info2[1]);
         }
       });
     }
@@ -20755,15 +20755,15 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
     }
     function getStackByFiberInDevAndProd(workInProgress2) {
       try {
-        var info = "", previous = null;
+        var info2 = "", previous = null;
         do {
-          info += describeFiber(workInProgress2, previous);
+          info2 += describeFiber(workInProgress2, previous);
           var debugInfo = workInProgress2._debugInfo;
           if (debugInfo)
             for (var i = debugInfo.length - 1;0 <= i; i--) {
               var entry = debugInfo[i];
               if (typeof entry.name === "string") {
-                var JSCompiler_temp_const = info;
+                var JSCompiler_temp_const = info2;
                 a: {
                   var { name, env: env2, debugLocation: location } = entry;
                   if (location != null) {
@@ -20777,13 +20777,13 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
                   }
                   JSCompiler_inline_result = describeBuiltInComponentFrame(name + (env2 ? " [" + env2 + "]" : ""));
                 }
-                info = JSCompiler_temp_const + JSCompiler_inline_result;
+                info2 = JSCompiler_temp_const + JSCompiler_inline_result;
               }
             }
           previous = workInProgress2;
           workInProgress2 = workInProgress2.return;
         } while (workInProgress2);
-        return info;
+        return info2;
       } catch (x) {
         return `
 Error generating stack: ` + x.message + `
@@ -21151,31 +21151,31 @@ Error generating stack: ` + x.message + `
         return "";
       var workInProgress2 = current;
       try {
-        var info = "";
+        var info2 = "";
         workInProgress2.tag === 6 && (workInProgress2 = workInProgress2.return);
         switch (workInProgress2.tag) {
           case 26:
           case 27:
           case 5:
-            info += describeBuiltInComponentFrame(workInProgress2.type);
+            info2 += describeBuiltInComponentFrame(workInProgress2.type);
             break;
           case 13:
-            info += describeBuiltInComponentFrame("Suspense");
+            info2 += describeBuiltInComponentFrame("Suspense");
             break;
           case 19:
-            info += describeBuiltInComponentFrame("SuspenseList");
+            info2 += describeBuiltInComponentFrame("SuspenseList");
             break;
           case 31:
-            info += describeBuiltInComponentFrame("Activity");
+            info2 += describeBuiltInComponentFrame("Activity");
             break;
           case 30:
           case 0:
           case 15:
           case 1:
-            workInProgress2._debugOwner || info !== "" || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress2.type));
+            workInProgress2._debugOwner || info2 !== "" || (info2 += describeFunctionComponentFrameWithoutLineNumber(workInProgress2.type));
             break;
           case 11:
-            workInProgress2._debugOwner || info !== "" || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress2.type.render));
+            workInProgress2._debugOwner || info2 !== "" || (info2 += describeFunctionComponentFrameWithoutLineNumber(workInProgress2.type.render));
         }
         for (;workInProgress2; )
           if (typeof workInProgress2.tag === "number") {
@@ -21184,16 +21184,16 @@ Error generating stack: ` + x.message + `
             var debugStack = fiber._debugStack;
             if (workInProgress2 && debugStack) {
               var formattedStack = formatOwnerStack(debugStack);
-              formattedStack !== "" && (info += `
+              formattedStack !== "" && (info2 += `
 ` + formattedStack);
             }
           } else if (workInProgress2.debugStack != null) {
             var ownerStack = workInProgress2.debugStack;
-            (workInProgress2 = workInProgress2.owner) && ownerStack && (info += `
+            (workInProgress2 = workInProgress2.owner) && ownerStack && (info2 += `
 ` + formatOwnerStack(ownerStack));
           } else
             break;
-        var JSCompiler_inline_result = info;
+        var JSCompiler_inline_result = info2;
       } catch (x) {
         JSCompiler_inline_result = `
 Error generating stack: ` + x.message + `
@@ -34551,13 +34551,13 @@ var require_websocket_server = __commonJS((exports, module) => {
         }
       }
       if (this.options.verifyClient) {
-        const info = {
+        const info2 = {
           origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
           secure: !!(req.socket.authorized || req.socket.encrypted),
           req
         };
         if (this.options.verifyClient.length === 2) {
-          this.options.verifyClient(info, (verified, code, message, headers) => {
+          this.options.verifyClient(info2, (verified, code, message, headers) => {
             if (!verified) {
               return abortHandshake(socket, code || 401, message, headers);
             }
@@ -34565,7 +34565,7 @@ var require_websocket_server = __commonJS((exports, module) => {
           });
           return;
         }
-        if (!this.options.verifyClient(info))
+        if (!this.options.verifyClient(info2))
           return abortHandshake(socket, 401);
       }
       this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
@@ -41539,7 +41539,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         function getOwnerStackByComponentInfoInDev(componentInfo) {
           try {
-            var info = "";
+            var info2 = "";
             if (!componentInfo.owner && typeof componentInfo.name === "string") {
               return describeBuiltInComponentFrame(componentInfo.name);
             }
@@ -41549,14 +41549,14 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (ownerStack != null) {
                 owner = owner.owner;
                 if (owner) {
-                  info += `
+                  info2 += `
 ` + formatOwnerStack(ownerStack);
                 }
               } else {
                 break;
               }
             }
-            return info;
+            return info2;
           } catch (x) {
             return `
 Error generating stack: ` + x.message + `
@@ -41819,22 +41819,22 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         function getStackByFiberInDevAndProd(workTagMap, workInProgress, currentDispatcherRef) {
           try {
-            var info = "";
+            var info2 = "";
             var node = workInProgress;
             do {
-              info += describeFiber(workTagMap, node, currentDispatcherRef);
+              info2 += describeFiber(workTagMap, node, currentDispatcherRef);
               var debugInfo = node._debugInfo;
               if (debugInfo) {
                 for (var i = debugInfo.length - 1;i >= 0; i--) {
                   var entry = debugInfo[i];
                   if (typeof entry.name === "string") {
-                    info += describeDebugInfoFrame(entry.name, entry.env);
+                    info2 += describeDebugInfoFrame(entry.name, entry.env);
                   }
                 }
               }
               node = node.return;
             } while (node);
-            return info;
+            return info2;
           } catch (x) {
             return `
 Error generating stack: ` + x.message + `
@@ -41843,9 +41843,9 @@ Error generating stack: ` + x.message + `
         }
         function getSourceLocationByFiber(workTagMap, fiber, currentDispatcherRef) {
           try {
-            var info = describeFiber(workTagMap, fiber, currentDispatcherRef);
-            if (info !== "") {
-              return info.slice(1);
+            var info2 = describeFiber(workTagMap, fiber, currentDispatcherRef);
+            if (info2 !== "") {
+              return info2.slice(1);
             }
           } catch (x) {
             console.error(x);
@@ -41861,7 +41861,7 @@ Error generating stack: ` + x.message + `
         function getOwnerStackByFiberInDev(workTagMap, workInProgress, currentDispatcherRef) {
           var { HostHoistable, HostSingleton, HostText, HostComponent, SuspenseComponent, SuspenseListComponent, ViewTransitionComponent, ActivityComponent } = workTagMap;
           try {
-            var info = "";
+            var info2 = "";
             if (workInProgress.tag === HostText) {
               workInProgress = workInProgress.return;
             }
@@ -41869,19 +41869,19 @@ Error generating stack: ` + x.message + `
               case HostHoistable:
               case HostSingleton:
               case HostComponent:
-                info += describeBuiltInComponentFrame(workInProgress.type);
+                info2 += describeBuiltInComponentFrame(workInProgress.type);
                 break;
               case SuspenseComponent:
-                info += describeBuiltInComponentFrame("Suspense");
+                info2 += describeBuiltInComponentFrame("Suspense");
                 break;
               case SuspenseListComponent:
-                info += describeBuiltInComponentFrame("SuspenseList");
+                info2 += describeBuiltInComponentFrame("SuspenseList");
                 break;
               case ViewTransitionComponent:
-                info += describeBuiltInComponentFrame("ViewTransition");
+                info2 += describeBuiltInComponentFrame("ViewTransition");
                 break;
               case ActivityComponent:
-                info += describeBuiltInComponentFrame("Activity");
+                info2 += describeBuiltInComponentFrame("Activity");
                 break;
             }
             var owner = workInProgress;
@@ -41895,7 +41895,7 @@ Error generating stack: ` + x.message + `
                     debugStack = formatOwnerStack(debugStack);
                   }
                   if (debugStack !== "") {
-                    info += `
+                    info2 += `
 ` + debugStack;
                   }
                 }
@@ -41903,14 +41903,14 @@ Error generating stack: ` + x.message + `
                 var ownerStack = owner.debugStack;
                 owner = owner.owner;
                 if (owner && ownerStack) {
-                  info += `
+                  info2 += `
 ` + formatOwnerStack(ownerStack);
                 }
               } else {
                 break;
               }
             }
-            return info;
+            return info2;
           } catch (x) {
             return `
 Error generating stack: ` + x.message + `
@@ -59652,13 +59652,1328 @@ var init_command11 = __esm(async () => {
   });
 });
 
+// src/lib/hooks/find-room.ts
+import { readdirSync, readFileSync as readFileSync4 } from "node:fs";
+import { join as join3 } from "node:path";
+function findRoomId(sessionId, teamsDir) {
+  const dir = teamsDir ?? `${process.env.HOME}/.claude/teams`;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const filePath = join3(dir, entry, "meet-ai.json");
+    try {
+      const raw = readFileSync4(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.session_id === sessionId) {
+        return data.room_id || null;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+var init_find_room = () => {};
+
+// src/lib/hooks/summarize.ts
+import { basename } from "node:path";
+function summarize(toolName, toolInput) {
+  const str = (key) => typeof toolInput[key] === "string" ? toolInput[key] : "";
+  const file2 = (key) => basename(str(key)) || "?";
+  switch (toolName) {
+    case "Edit": {
+      return `Edit: ${file2("file_path")}`;
+    }
+    case "Read": {
+      return `Read: ${file2("file_path")}`;
+    }
+    case "Write": {
+      return `Write: ${file2("file_path")}`;
+    }
+    case "Bash": {
+      return `Bash: ${truncate(str("command"), 60)}`;
+    }
+    case "Grep": {
+      return `Grep: "${str("pattern")}" in ${str("glob") || str("path")}`;
+    }
+    case "Glob": {
+      return `Glob: ${str("pattern")}`;
+    }
+    case "Task": {
+      return `Task: ${truncate(str("description"), 60)}`;
+    }
+    case "WebFetch": {
+      return `WebFetch: ${str("url")}`;
+    }
+    case "WebSearch": {
+      return `WebSearch: ${str("query")}`;
+    }
+    default: {
+      return toolName;
+    }
+  }
+}
+var truncate = (s, n) => s.slice(0, n);
+var init_summarize = () => {};
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/utils/url.js
+var init_url = () => {};
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/utils/cookie.js
+var _serialize = (name, value, opt = {}) => {
+  let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
+  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 34560000) {
+      throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+    }
+    cookie += `; Max-Age=${opt.maxAge | 0}`;
+  }
+  if (opt.domain && opt.prefix !== "host") {
+    cookie += `; Domain=${opt.domain}`;
+  }
+  if (opt.path) {
+    cookie += `; Path=${opt.path}`;
+  }
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 34560000000) {
+      throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+    }
+    cookie += `; Expires=${opt.expires.toUTCString()}`;
+  }
+  if (opt.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (opt.secure) {
+    cookie += "; Secure";
+  }
+  if (opt.sameSite) {
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+  }
+  if (opt.priority) {
+    cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+  }
+  if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
+    cookie += "; Partitioned";
+  }
+  return cookie;
+}, serialize = (name, value, opt) => {
+  value = encodeURIComponent(value);
+  return _serialize(name, value, opt);
+};
+var init_cookie = __esm(() => {
+  init_url();
+});
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/fetch-result-please.js
+var init_fetch_result_please = () => {};
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/utils.js
+function isObject2(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (!isObject2(target) && !isObject2(source)) {
+    return source;
+  }
+  const merged = { ...target };
+  for (const key in source) {
+    const value = source[key];
+    if (isObject2(merged[key]) && isObject2(value)) {
+      merged[key] = deepMerge(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+var mergePath = (base2, path) => {
+  base2 = base2.replace(/\/+$/, "");
+  base2 = base2 + "/";
+  path = path.replace(/^\/+/, "");
+  return base2 + path;
+}, replaceUrlParam = (urlString, params) => {
+  for (const [k, v] of Object.entries(params)) {
+    const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??");
+    urlString = urlString.replace(reg, v ? `/${v}` : "");
+  }
+  return urlString;
+}, buildSearchParams = (query) => {
+  const searchParams = new URLSearchParams;
+  for (const [k, v] of Object.entries(query)) {
+    if (v === undefined) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (const v2 of v) {
+        searchParams.append(k, v2);
+      }
+    } else {
+      searchParams.set(k, v);
+    }
+  }
+  return searchParams;
+}, replaceUrlProtocol = (urlString, protocol) => {
+  switch (protocol) {
+    case "ws":
+      return urlString.replace(/^http/, "ws");
+    case "http":
+      return urlString.replace(/^ws/, "http");
+  }
+}, removeIndexString = (urlString) => {
+  if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) {
+    return urlString.replace(/\/index(?=\?|$)/, "/");
+  }
+  return urlString.replace(/\/index(?=\?|$)/, "");
+};
+var init_utils2 = __esm(() => {
+  init_fetch_result_please();
+});
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/client.js
+var createProxy = (callback, path) => {
+  const proxy = new Proxy(() => {}, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") {
+        return;
+      }
+      return createProxy(callback, [...path, key]);
+    },
+    apply(_1, _2, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+}, ClientRequestImpl = class {
+  url;
+  method;
+  buildSearchParams;
+  queryParams = undefined;
+  pathParams = {};
+  rBody;
+  cType = undefined;
+  constructor(url2, method, options) {
+    this.url = url2;
+    this.method = method;
+    this.buildSearchParams = options.buildSearchParams;
+  }
+  fetch = async (args, opt) => {
+    if (args) {
+      if (args.query) {
+        this.queryParams = this.buildSearchParams(args.query);
+      }
+      if (args.form) {
+        const form = new FormData;
+        for (const [k, v] of Object.entries(args.form)) {
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
+        }
+        this.rBody = form;
+      }
+      if (args.json) {
+        this.rBody = JSON.stringify(args.json);
+        this.cType = "application/json";
+      }
+      if (args.param) {
+        this.pathParams = args.param;
+      }
+    }
+    let methodUpperCase = this.method.toUpperCase();
+    const headerValues = {
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
+    };
+    if (args?.cookie) {
+      const cookies = [];
+      for (const [key, value] of Object.entries(args.cookie)) {
+        cookies.push(serialize(key, value, { path: "/" }));
+      }
+      headerValues["Cookie"] = cookies.join(",");
+    }
+    if (this.cType) {
+      headerValues["Content-Type"] = this.cType;
+    }
+    const headers = new Headers(headerValues ?? undefined);
+    let url2 = this.url;
+    url2 = removeIndexString(url2);
+    url2 = replaceUrlParam(url2, this.pathParams);
+    if (this.queryParams) {
+      url2 = url2 + "?" + this.queryParams.toString();
+    }
+    methodUpperCase = this.method.toUpperCase();
+    const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    return (opt?.fetch || fetch)(url2, {
+      body: setBody ? this.rBody : undefined,
+      method: methodUpperCase,
+      headers,
+      ...opt?.init
+    });
+  };
+}, hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
+  const buildSearchParamsOption = options?.buildSearchParams ?? buildSearchParams;
+  const parts = [...opts.path];
+  const lastParts = parts.slice(-3).reverse();
+  if (lastParts[0] === "toString") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback.toString();
+  }
+  if (lastParts[0] === "valueOf") {
+    if (lastParts[1] === "name") {
+      return lastParts[2] || "";
+    }
+    return proxyCallback;
+  }
+  let method = "";
+  if (/^\$/.test(lastParts[0])) {
+    const last = parts.pop();
+    if (last) {
+      method = last.replace(/^\$/, "");
+    }
+  }
+  const path = parts.join("/");
+  const url2 = mergePath(baseUrl, path);
+  if (method === "url") {
+    let result = url2;
+    if (opts.args[0]) {
+      if (opts.args[0].param) {
+        result = replaceUrlParam(url2, opts.args[0].param);
+      }
+      if (opts.args[0].query) {
+        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+      }
+    }
+    result = removeIndexString(result);
+    return new URL(result);
+  }
+  if (method === "ws") {
+    const webSocketUrl = replaceUrlProtocol(opts.args[0] && opts.args[0].param ? replaceUrlParam(url2, opts.args[0].param) : url2, "ws");
+    const targetUrl = new URL(webSocketUrl);
+    const queryParams = opts.args[0]?.query;
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((item) => targetUrl.searchParams.append(key, item));
+        } else {
+          targetUrl.searchParams.set(key, value);
+        }
+      });
+    }
+    const establishWebSocket = (...args) => {
+      if (options?.webSocket !== undefined && typeof options.webSocket === "function") {
+        return options.webSocket(...args);
+      }
+      return new WebSocket(...args);
+    };
+    return establishWebSocket(targetUrl.toString());
+  }
+  const req = new ClientRequestImpl(url2, method, {
+    buildSearchParams: buildSearchParamsOption
+  });
+  if (method) {
+    options ??= {};
+    const args = deepMerge(options, { ...opts.args[1] });
+    return req.fetch(opts.args[0], args);
+  }
+  return req;
+}, []);
+var init_client2 = __esm(() => {
+  init_cookie();
+  init_utils2();
+});
+
+// ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/index.js
+var init_client3 = __esm(() => {
+  init_client2();
+  init_utils2();
+});
+
+// src/lib/hooks/client.ts
+function createHookClient(url2, key) {
+  return hc(url2, {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${key}`
+    }
+  });
+}
+async function sendParentMessage(client, roomId) {
+  try {
+    const res = await client.api.rooms[":id"].messages.$post({
+      param: { id: roomId },
+      json: {
+        sender: HOOK_SENDER,
+        content: "Agent activity",
+        sender_type: "agent",
+        color: HOOK_COLOR
+      }
+    });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return data.id;
+  } catch {
+    return null;
+  }
+}
+async function sendLogEntry(client, roomId, summary, messageId) {
+  try {
+    await client.api.rooms[":id"].logs.$post({
+      param: { id: roomId },
+      json: {
+        sender: HOOK_SENDER,
+        content: summary,
+        color: HOOK_COLOR,
+        ...messageId ? { message_id: messageId } : {}
+      }
+    });
+  } catch {}
+}
+var HOOK_COLOR = "#6b7280", HOOK_SENDER = "hook";
+var init_client4 = __esm(() => {
+  init_client3();
+});
+
+// src/lib/hooks/index.ts
+var init_hooks = __esm(() => {
+  init_find_room();
+  init_summarize();
+  init_client4();
+});
+
+// src/commands/hook/log-tool-use/usecase.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, statSync as statSync2, rmSync } from "node:fs";
+function getOrCreateParentId(sessionId) {
+  const path = `/tmp/meet-ai-hook-${sessionId}.msgid`;
+  try {
+    const mtime = statSync2(path).mtimeMs;
+    if (Date.now() - mtime > PARENT_MSG_TTL_SEC * 1000) {
+      rmSync(path, { force: true });
+      return null;
+    }
+    return readFileSync5(path, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function saveParentId(sessionId, msgId) {
+  try {
+    writeFileSync2(`/tmp/meet-ai-hook-${sessionId}.msgid`, msgId);
+  } catch {}
+}
+async function processHookInput(rawInput, teamsDir) {
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    return "skip";
+  }
+  const { session_id: sessionId, tool_name: toolName, tool_input: toolInput = {} } = input;
+  if (!sessionId || !toolName)
+    return "skip";
+  if (toolName === "SendMessage")
+    return "skip";
+  if (toolName === "Bash") {
+    const cmd = typeof toolInput.command === "string" ? toolInput.command : "";
+    if (cmd.startsWith("cd ") || cmd.startsWith("meet-ai "))
+      return "skip";
+  }
+  const roomId = findRoomId(sessionId, teamsDir);
+  if (!roomId)
+    return "skip";
+  const url2 = process.env.MEET_AI_URL;
+  const key = process.env.MEET_AI_KEY;
+  if (!url2 || !key)
+    return "skip";
+  const client = createHookClient(url2, key);
+  const summary = summarize(toolName, toolInput);
+  let parentId = getOrCreateParentId(sessionId);
+  if (!parentId) {
+    parentId = await sendParentMessage(client, roomId);
+    if (parentId)
+      saveParentId(sessionId, parentId);
+  }
+  await sendLogEntry(client, roomId, summary, parentId ?? undefined);
+  return "sent";
+}
+var PARENT_MSG_TTL_SEC = 120;
+var init_usecase11 = __esm(() => {
+  init_hooks();
+  init_hooks();
+  init_hooks();
+});
+
+// src/commands/hook/log-tool-use/command.ts
+var exports_command12 = {};
+__export(exports_command12, {
+  default: () => command_default12
+});
+var command_default12;
+var init_command12 = __esm(() => {
+  init_dist();
+  init_usecase11();
+  command_default12 = defineCommand({
+    meta: {
+      name: "log-tool-use",
+      description: "Hook: log tool use events to a chat room"
+    },
+    async run() {
+      try {
+        let input = "";
+        for await (const chunk of process.stdin) {
+          input += chunk;
+        }
+        await processHookInput(input);
+      } catch {}
+      process.exit(0);
+    }
+  });
+});
+
+// src/commands/hook/plan-review/usecase.ts
+var exports_usecase2 = {};
+__export(exports_usecase2, {
+  processPlanReview: () => processPlanReview
+});
+import { setTimeout as delay } from "node:timers/promises";
+async function createPlanReview(client, roomId, planContent) {
+  try {
+    const res = await client.api.rooms[":id"]["plan-reviews"].$post({
+      param: { id: roomId },
+      json: { plan_content: planContent }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      process.stderr.write(`[plan-review] create failed: ${res.status} ${text}
+`);
+      return null;
+    }
+    return await res.json();
+  } catch (error48) {
+    process.stderr.write(`[plan-review] create error: ${error48}
+`);
+    return null;
+  }
+}
+async function pollForDecision(client, roomId, reviewId) {
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const res = await client.api.rooms[":id"]["plan-reviews"][":reviewId"].$get({
+        param: { id: roomId, reviewId }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.status !== "pending") {
+          return data;
+        }
+      }
+    } catch (error48) {
+      process.stderr.write(`[plan-review] poll error: ${error48}
+`);
+    }
+    await delay(POLL_INTERVAL_MS);
+  }
+  return null;
+}
+function getPromptsByMode(mode) {
+  switch (mode) {
+    case "acceptEdits": {
+      return [
+        { tool: "Bash", prompt: "install dependencies" },
+        { tool: "Bash", prompt: "run tests" },
+        { tool: "Bash", prompt: "run build" },
+        { tool: "Bash", prompt: "run typecheck" },
+        { tool: "Bash", prompt: "run linter" }
+      ];
+    }
+    case "bypassPermissions": {
+      return [{ tool: "Bash", prompt: "run any command" }];
+    }
+    default: {
+      return;
+    }
+  }
+}
+function buildAllowOutput(permissionMode) {
+  const allowedPrompts = getPromptsByMode(permissionMode);
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: allowedPrompts ? { behavior: "allow", allowedPrompts } : { behavior: "allow" }
+    }
+  };
+}
+function buildDenyOutput(feedback) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: {
+        behavior: "deny",
+        message: feedback
+      }
+    }
+  };
+}
+async function expirePlanReview(client, roomId, reviewId) {
+  try {
+    await client.api.rooms[":id"]["plan-reviews"][":reviewId"].expire.$post({
+      param: { id: roomId, reviewId }
+    });
+  } catch {}
+}
+async function processPlanReview(rawInput, teamsDir) {
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    process.stderr.write(`[plan-review] failed to parse stdin
+`);
+    return;
+  }
+  const { session_id: sessionId } = input;
+  if (!sessionId) {
+    process.stderr.write(`[plan-review] missing session_id
+`);
+    return;
+  }
+  const planContent = input.tool_input?.plan || "_Agent requested to exit plan mode without a plan._";
+  const roomId = findRoomId(sessionId, teamsDir);
+  if (!roomId) {
+    process.stderr.write(`[plan-review] no room found for session
+`);
+    return;
+  }
+  const url2 = process.env.MEET_AI_URL;
+  const key = process.env.MEET_AI_KEY;
+  if (!url2 || !key) {
+    process.stderr.write(`[plan-review] MEET_AI_URL or MEET_AI_KEY not set
+`);
+    return;
+  }
+  const client = createHookClient(url2, key);
+  process.stderr.write(`[plan-review] sending plan to room ${roomId} via ${url2}
+`);
+  const review = await createPlanReview(client, roomId, planContent);
+  if (!review)
+    return;
+  process.stderr.write(`[plan-review] plan review created: ${review.id}, polling for decision...
+`);
+  const decision = await pollForDecision(client, roomId, review.id);
+  if (!decision) {
+    process.stderr.write(`[plan-review] timed out waiting for decision
+`);
+    await expirePlanReview(client, roomId, review.id);
+    return;
+  }
+  process.stderr.write(`[plan-review] decision: ${decision.status}
+`);
+  if (decision.status === "approved" || decision.status === "expired") {
+    process.stdout.write(JSON.stringify(buildAllowOutput(decision.permission_mode)));
+  } else if (decision.status === "denied") {
+    const feedback = decision.feedback || "Plan was rejected. Please revise the plan based on the feedback.";
+    process.stdout.write(JSON.stringify(buildDenyOutput(feedback)));
+  }
+}
+var POLL_INTERVAL_MS = 2000, POLL_TIMEOUT_MS = 2592000000;
+var init_usecase12 = __esm(() => {
+  init_client4();
+  init_find_room();
+});
+
+// src/commands/hook/plan-review/command.ts
+var exports_command13 = {};
+__export(exports_command13, {
+  default: () => command_default13
+});
+var command_default13;
+var init_command13 = __esm(() => {
+  init_dist();
+  command_default13 = defineCommand({
+    meta: {
+      name: "plan-review",
+      description: "Claude Code hook: send plan for review and poll for decision"
+    },
+    async run() {
+      try {
+        let input = "";
+        for await (const chunk of process.stdin) {
+          input += chunk;
+        }
+        const { processPlanReview: processPlanReview2 } = await Promise.resolve().then(() => (init_usecase12(), exports_usecase2));
+        await processPlanReview2(input);
+      } catch (error48) {
+        process.stderr.write(`[plan-review] fatal: ${error48}
+`);
+      }
+      process.exit(0);
+    }
+  });
+});
+
+// src/commands/hook/question-review/usecase.ts
+function formatQuestions(questions) {
+  return questions.map((q) => {
+    let text = `**${q.question}**
+`;
+    for (let i = 0;i < q.options.length; i++) {
+      const opt = q.options[i];
+      text += `${i + 1}. **${opt.label}**`;
+      if (opt.description)
+        text += ` — ${opt.description}`;
+      text += `
+`;
+    }
+    if (q.multiSelect) {
+      text += `
+_Multiple choices allowed._`;
+    }
+    return text;
+  }).join(`
+
+`);
+}
+async function createQuestionReview(client, roomId, questions, formattedContent) {
+  try {
+    const res = await client.api.rooms[":id"]["question-reviews"].$post({
+      param: { id: roomId },
+      json: {
+        questions_json: JSON.stringify(questions),
+        formatted_content: formattedContent
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      process.stderr.write(`[question-review] create failed: ${res.status} ${text}
+`);
+      return null;
+    }
+    return await res.json();
+  } catch (error48) {
+    process.stderr.write(`[question-review] create error: ${error48}
+`);
+    return null;
+  }
+}
+async function pollForAnswer(client, roomId, reviewId, pollInterval = POLL_INTERVAL_MS2, pollTimeout = POLL_TIMEOUT_MS2) {
+  const deadline = Date.now() + pollTimeout;
+  while (Date.now() < deadline) {
+    try {
+      const res = await client.api.rooms[":id"]["question-reviews"][":reviewId"].$get({
+        param: { id: roomId, reviewId }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.status !== "pending") {
+          return data;
+        }
+      }
+    } catch (error48) {
+      process.stderr.write(`[question-review] poll error: ${error48}
+`);
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  return null;
+}
+function buildOutput(questions, answers) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: {
+        behavior: "allow",
+        updatedInput: {
+          questions,
+          answers
+        }
+      }
+    }
+  };
+}
+async function expireReview(client, roomId, reviewId) {
+  try {
+    await client.api.rooms[":id"]["question-reviews"][":reviewId"].expire.$post({
+      param: { id: roomId, reviewId }
+    });
+  } catch {}
+}
+async function sendTimeoutMessage(client, roomId) {
+  try {
+    await client.api.rooms[":id"].messages.$post({
+      param: { id: roomId },
+      json: {
+        sender: "hook",
+        content: "_Question timed out — answer in terminal instead._",
+        sender_type: "agent",
+        color: "#f59e0b"
+      }
+    });
+  } catch {}
+}
+async function processQuestionReview(rawInput, teamsDir, opts) {
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    process.stderr.write(`[question-review] failed to parse stdin
+`);
+    return;
+  }
+  const { session_id: sessionId, hook_event_name: hookEventName, tool_input: toolInput } = input;
+  if (!sessionId || !toolInput?.questions?.length) {
+    process.stderr.write(`[question-review] missing session_id or questions
+`);
+    return;
+  }
+  process.stderr.write(`[question-review] triggered by ${hookEventName} event
+`);
+  const roomId = findRoomId(sessionId, teamsDir);
+  if (!roomId) {
+    process.stderr.write(`[question-review] no room found for session
+`);
+    return;
+  }
+  const url2 = process.env.MEET_AI_URL;
+  const key = process.env.MEET_AI_KEY;
+  if (!url2 || !key) {
+    process.stderr.write(`[question-review] MEET_AI_URL or MEET_AI_KEY not set
+`);
+    return;
+  }
+  const client = createHookClient(url2, key);
+  const formattedContent = formatQuestions(toolInput.questions);
+  process.stderr.write(`[question-review] sending question to room ${roomId} via ${url2}
+`);
+  const review = await createQuestionReview(client, roomId, toolInput.questions, formattedContent);
+  if (!review)
+    return;
+  process.stderr.write(`[question-review] created: ${review.id}, polling for answer...
+`);
+  const result = await pollForAnswer(client, roomId, review.id, opts?.pollInterval, opts?.pollTimeout);
+  if (!result) {
+    process.stderr.write(`[question-review] timed out waiting for answer
+`);
+    await expireReview(client, roomId, review.id);
+    await sendTimeoutMessage(client, roomId);
+    return;
+  }
+  process.stderr.write(`[question-review] answer received: ${result.status}
+`);
+  if (result.status === "answered" && result.answers_json) {
+    let answers;
+    try {
+      answers = JSON.parse(result.answers_json);
+    } catch (error48) {
+      process.stderr.write(`[question-review] failed to parse answers_json: ${error48}
+`);
+      return;
+    }
+    process.stdout.write(JSON.stringify(buildOutput(toolInput.questions, answers)));
+  }
+}
+var POLL_INTERVAL_MS2 = 2000, POLL_TIMEOUT_MS2 = 1800000;
+var init_usecase13 = __esm(() => {
+  init_client4();
+  init_find_room();
+});
+
+// src/commands/hook/question-review/command.ts
+var exports_command14 = {};
+__export(exports_command14, {
+  default: () => command_default14
+});
+var command_default14;
+var init_command14 = __esm(() => {
+  init_dist();
+  init_usecase13();
+  command_default14 = defineCommand({
+    meta: {
+      name: "question-review",
+      description: "Handle Claude Code AskUser permission hook — routes questions to meet-ai room for review"
+    },
+    async run() {
+      try {
+        let input = "";
+        for await (const chunk of process.stdin) {
+          input += chunk;
+        }
+        await processQuestionReview(input);
+      } catch (error48) {
+        process.stderr.write(`[question-review] fatal: ${error48}
+`);
+      }
+      process.exit(0);
+    }
+  });
+});
+
+// src/commands/hook/permission-review/usecase.ts
+function formatPermissionRequest(toolName, toolInput) {
+  let text = `**Permission request: ${toolName}**
+`;
+  if (toolInput) {
+    const entries = Object.entries(toolInput);
+    if (entries.length > 0) {
+      for (const [key, value] of entries) {
+        const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+        const truncated = valueStr.length > 200 ? valueStr.slice(0, 200) + "..." : valueStr;
+        text += `
+**${key}:** \`${truncated}\``;
+      }
+    }
+  }
+  return text;
+}
+async function createPermissionReview(client, roomId, toolName, toolInput, formattedContent) {
+  try {
+    const res = await client.api.rooms[":id"]["permission-reviews"].$post({
+      param: { id: roomId },
+      json: {
+        tool_name: toolName,
+        tool_input_json: toolInput ? JSON.stringify(toolInput) : undefined,
+        formatted_content: formattedContent
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      process.stderr.write(`[permission-review] create failed: ${res.status} ${text}
+`);
+      return null;
+    }
+    return await res.json();
+  } catch (error48) {
+    process.stderr.write(`[permission-review] create error: ${error48}
+`);
+    return null;
+  }
+}
+async function pollForDecision2(client, roomId, reviewId, pollInterval = POLL_INTERVAL_MS3, pollTimeout = POLL_TIMEOUT_MS3) {
+  const deadline = Date.now() + pollTimeout;
+  while (Date.now() < deadline) {
+    try {
+      const res = await client.api.rooms[":id"]["permission-reviews"][":reviewId"].$get({
+        param: { id: roomId, reviewId }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.status !== "pending") {
+          return data;
+        }
+      }
+    } catch (error48) {
+      process.stderr.write(`[permission-review] poll error: ${error48}
+`);
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  return null;
+}
+function buildAllowOutput2() {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: { behavior: "allow" }
+    }
+  };
+}
+function buildDenyOutput2(message) {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PermissionRequest",
+      decision: {
+        behavior: "deny",
+        message
+      }
+    }
+  };
+}
+async function expireReview2(client, roomId, reviewId) {
+  try {
+    await client.api.rooms[":id"]["permission-reviews"][":reviewId"].expire.$post({
+      param: { id: roomId, reviewId }
+    });
+  } catch {}
+}
+async function sendTimeoutMessage2(client, roomId) {
+  try {
+    await client.api.rooms[":id"].messages.$post({
+      param: { id: roomId },
+      json: {
+        sender: "hook",
+        content: "_Permission request timed out — approve in terminal instead._",
+        sender_type: "agent",
+        color: "#f97316"
+      }
+    });
+  } catch {}
+}
+async function processPermissionReview(rawInput, teamsDir, opts) {
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    process.stderr.write(`[permission-review] failed to parse stdin
+`);
+    return;
+  }
+  const { session_id: sessionId, hook_event_name: hookEventName, tool_name: toolName, tool_input: toolInput } = input;
+  if (!sessionId || !toolName) {
+    process.stderr.write(`[permission-review] missing session_id or tool_name
+`);
+    return;
+  }
+  const EXCLUDED_TOOLS = ["ExitPlanMode", "AskUserQuestion"];
+  if (EXCLUDED_TOOLS.includes(toolName)) {
+    process.stderr.write(`[permission-review] skipping ${toolName} — handled by dedicated hook
+`);
+    return;
+  }
+  process.stderr.write(`[permission-review] triggered by ${hookEventName} for tool ${toolName}
+`);
+  const roomId = findRoomId(sessionId, teamsDir);
+  if (!roomId) {
+    process.stderr.write(`[permission-review] no room found for session
+`);
+    return;
+  }
+  const url2 = process.env.MEET_AI_URL;
+  const key = process.env.MEET_AI_KEY;
+  if (!url2 || !key) {
+    process.stderr.write(`[permission-review] MEET_AI_URL or MEET_AI_KEY not set
+`);
+    return;
+  }
+  const client = createHookClient(url2, key);
+  const formattedContent = formatPermissionRequest(toolName, toolInput);
+  process.stderr.write(`[permission-review] sending permission request to room ${roomId} via ${url2}
+`);
+  const review = await createPermissionReview(client, roomId, toolName, toolInput, formattedContent);
+  if (!review)
+    return;
+  process.stderr.write(`[permission-review] created: ${review.id}, polling for decision...
+`);
+  const result = await pollForDecision2(client, roomId, review.id, opts?.pollInterval, opts?.pollTimeout);
+  if (!result) {
+    process.stderr.write(`[permission-review] timed out waiting for decision
+`);
+    await expireReview2(client, roomId, review.id);
+    await sendTimeoutMessage2(client, roomId);
+    return;
+  }
+  process.stderr.write(`[permission-review] decision received: ${result.status}
+`);
+  if (result.status === "approved") {
+    process.stdout.write(JSON.stringify(buildAllowOutput2()));
+  } else if (result.status === "denied") {
+    const message = result.feedback || "Permission denied by user.";
+    process.stdout.write(JSON.stringify(buildDenyOutput2(message)));
+  }
+}
+var POLL_INTERVAL_MS3 = 2000, POLL_TIMEOUT_MS3 = 1800000;
+var init_usecase14 = __esm(() => {
+  init_client4();
+  init_find_room();
+});
+
+// src/commands/hook/permission-review/command.ts
+var exports_command15 = {};
+__export(exports_command15, {
+  default: () => command_default15
+});
+var command_default15;
+var init_command15 = __esm(() => {
+  init_dist();
+  init_usecase14();
+  command_default15 = defineCommand({
+    meta: {
+      name: "permission-review",
+      description: "Handle Claude Code PermissionRequest hook — routes tool permission requests to meet-ai room for review"
+    },
+    async run() {
+      try {
+        let input = "";
+        for await (const chunk of process.stdin) {
+          input += chunk;
+        }
+        await processPermissionReview(input);
+      } catch (error48) {
+        process.stderr.write(`[permission-review] fatal: ${error48}
+`);
+      }
+      process.exit(0);
+    }
+  });
+});
+
+// src/commands/hook/command.ts
+var exports_command16 = {};
+__export(exports_command16, {
+  default: () => command_default16
+});
+var command_default16;
+var init_command16 = __esm(() => {
+  init_dist();
+  command_default16 = defineCommand({
+    meta: {
+      name: "hook",
+      description: "Claude Code hook subcommands"
+    },
+    subCommands: {
+      "log-tool-use": () => Promise.resolve().then(() => (init_command12(), exports_command12)).then((m) => m.default),
+      "plan-review": () => Promise.resolve().then(() => (init_command13(), exports_command13)).then((m) => m.default),
+      "question-review": () => Promise.resolve().then(() => (init_command14(), exports_command14)).then((m) => m.default),
+      "permission-review": () => Promise.resolve().then(() => (init_command15(), exports_command15)).then((m) => m.default)
+    }
+  });
+});
+
+// src/commands/setup-hooks/usecase.ts
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve2, dirname as dirname2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+function isMeetAiHook(entry) {
+  return entry.hooks?.some((h) => typeof h.command === "string" && h.command.startsWith("meet-ai hook ")) ?? false;
+}
+function getSettingsPath(project) {
+  if (project) {
+    return resolve2(process.cwd(), ".claude", "settings.json");
+  }
+  return resolve2(homedir3(), ".claude", "settings.json");
+}
+async function readSettings(path) {
+  if (!existsSync4(path)) {
+    return {};
+  }
+  const raw = await readFile(path, "utf-8");
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return {};
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return {};
+  }
+}
+function mergeHooks(existing) {
+  const result = { ...existing };
+  const added = [];
+  for (const [event, matchers] of Object.entries(MEET_AI_HOOKS)) {
+    if (!result[event]) {
+      result[event] = [];
+    }
+    for (const newMatcher of matchers) {
+      const existingIdx = result[event].findIndex((m) => m.matcher === newMatcher.matcher && isMeetAiHook(m));
+      if (existingIdx >= 0) {
+        result[event][existingIdx] = newMatcher;
+        added.push(`updated ${event} [${newMatcher.matcher}]`);
+      } else {
+        result[event].push(newMatcher);
+        added.push(`added ${event} [${newMatcher.matcher}]`);
+      }
+    }
+  }
+  return { merged: result, added };
+}
+function removeHooks(existing) {
+  const result = {};
+  const removed = [];
+  for (const [event, matchers] of Object.entries(existing)) {
+    const kept = matchers.filter((m) => {
+      if (isMeetAiHook(m)) {
+        removed.push(`removed ${event} [${m.matcher}]`);
+        return false;
+      }
+      return true;
+    });
+    if (kept.length > 0) {
+      result[event] = kept;
+    }
+  }
+  return { cleaned: result, removed };
+}
+async function setupHooks(options) {
+  const settingsPath = options._settingsPath ?? getSettingsPath(options.project);
+  const settings = await readSettings(settingsPath);
+  const existingHooks = settings.hooks ?? {};
+  if (options.remove) {
+    const { cleaned, removed } = removeHooks(existingHooks);
+    if (removed.length === 0) {
+      info("No meet-ai hooks found to remove.");
+      return;
+    }
+    if (options.dryRun) {
+      info(`Dry run — would modify ${settingsPath}:`);
+      for (const r of removed) {
+        console.log(import_picocolors2.default.yellow(`  ${r}`));
+      }
+      return;
+    }
+    const updated = { ...settings, hooks: cleaned };
+    if (Object.keys(cleaned).length === 0) {
+      delete updated.hooks;
+    }
+    await mkdir(dirname2(settingsPath), { recursive: true });
+    await writeFile(settingsPath, JSON.stringify(updated, null, 2) + `
+`);
+    for (const r of removed) {
+      console.log(import_picocolors2.default.yellow(`  ${r}`));
+    }
+    ok(`Removed meet-ai hooks from ${settingsPath}`);
+  } else {
+    const { merged, added } = mergeHooks(existingHooks);
+    if (options.dryRun) {
+      info(`Dry run — would modify ${settingsPath}:`);
+      for (const a of added) {
+        console.log(import_picocolors2.default.green(`  ${a}`));
+      }
+      return;
+    }
+    const updated = { ...settings, hooks: merged };
+    await mkdir(dirname2(settingsPath), { recursive: true });
+    await writeFile(settingsPath, JSON.stringify(updated, null, 2) + `
+`);
+    for (const a of added) {
+      console.log(import_picocolors2.default.green(`  ${a}`));
+    }
+    ok(`Hooks written to ${settingsPath}`);
+  }
+}
+var import_picocolors2, MEET_AI_HOOKS;
+var init_usecase15 = __esm(() => {
+  init_output();
+  import_picocolors2 = __toESM(require_picocolors(), 1);
+  MEET_AI_HOOKS = {
+    PostToolUse: [
+      {
+        matcher: ".*",
+        hooks: [
+          {
+            type: "command",
+            command: "meet-ai hook log-tool-use",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PermissionRequest: [
+      {
+        matcher: "ExitPlanMode",
+        hooks: [
+          {
+            type: "command",
+            command: "meet-ai hook plan-review",
+            timeout: 2592000
+          }
+        ]
+      },
+      {
+        matcher: "AskUserQuestion",
+        hooks: [
+          {
+            type: "command",
+            command: "meet-ai hook question-review",
+            timeout: 1800
+          }
+        ]
+      },
+      {
+        matcher: ".*",
+        hooks: [
+          {
+            type: "command",
+            command: "meet-ai hook permission-review",
+            timeout: 1800
+          }
+        ]
+      }
+    ]
+  };
+});
+
+// src/commands/setup-hooks/command.ts
+var exports_command17 = {};
+__export(exports_command17, {
+  default: () => command_default17
+});
+var command_default17;
+var init_command17 = __esm(() => {
+  init_dist();
+  init_usecase15();
+  init_output();
+  command_default17 = defineCommand({
+    meta: {
+      name: "setup-hooks",
+      description: "Configure Claude Code hooks for meet-ai in ~/.claude/settings.json"
+    },
+    args: {
+      project: {
+        type: "boolean",
+        description: "Write to ./.claude/settings.json instead of ~/.claude/settings.json",
+        default: false
+      },
+      "dry-run": {
+        type: "boolean",
+        description: "Print what would be written without actually writing",
+        default: false
+      },
+      remove: {
+        type: "boolean",
+        description: "Remove meet-ai hooks from settings instead of adding them",
+        default: false
+      }
+    },
+    async run({ args }) {
+      try {
+        await setupHooks({
+          project: args.project,
+          dryRun: args["dry-run"],
+          remove: args.remove
+        });
+      } catch (error48) {
+        err(error48 instanceof Error ? error48.message : String(error48));
+        process.exit(1);
+      }
+    }
+  });
+});
+
 // src/index.ts
 init_dist();
 init_output();
 var main = defineCommand({
   meta: {
     name: "meet-ai",
-    version: "0.0.18",
+    version: "0.0.19",
     description: "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket"
   },
   args: {
@@ -59679,7 +60994,9 @@ var main = defineCommand({
     "send-tasks": () => Promise.resolve().then(() => (init_command8(), exports_command8)).then((m) => m.default),
     "download-attachment": () => Promise.resolve().then(() => (init_command9(), exports_command9)).then((m) => m.default),
     "generate-key": () => Promise.resolve().then(() => (init_command10(), exports_command10)).then((m) => m.default),
-    dashboard: () => init_command11().then(() => exports_command11).then((m) => m.default)
+    dashboard: () => init_command11().then(() => exports_command11).then((m) => m.default),
+    hook: () => Promise.resolve().then(() => (init_command16(), exports_command16)).then((m) => m.default),
+    "setup-hooks": () => Promise.resolve().then(() => (init_command17(), exports_command17)).then((m) => m.default)
   },
   async run({ args }) {
     const hasSubcommand = process.argv.length > 2;