@zhigang1992/happy-cli 0.12.12 → 0.12.14

package/dist/{index-DLt6o6FN.cjs → index-DGfkEaE6.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var types = require('./types-CGvx6DSD.cjs');
+var types = require('./types-Cxw1JC-9.cjs');
 var node_child_process = require('node:child_process');
 var node_path = require('node:path');
 var node_readline = require('node:readline');
@@ -74,9 +74,15 @@ class Session {
   allowedTools;
   _onModeChange;
   initialPermissionMode;
+  /** Path to temporary settings file with SessionStart hook (required for session tracking) */
+  hookSettingsPath;
   sessionId;
   mode = "local";
   thinking = false;
+  /** Callbacks to be notified when session ID is found/changed */
+  sessionFoundCallbacks = [];
+  /** Keep alive interval reference for cleanup */
+  keepAliveInterval;
   constructor(opts) {
     this.path = opts.path;
     this.api = opts.api;
@@ -90,11 +96,20 @@ class Session {
     this.allowedTools = opts.allowedTools;
     this._onModeChange = opts.onModeChange;
     this.initialPermissionMode = opts.initialPermissionMode ?? "default";
+    this.hookSettingsPath = opts.hookSettingsPath;
     this.client.keepAlive(this.thinking, this.mode);
-    setInterval(() => {
+    this.keepAliveInterval = setInterval(() => {
       this.client.keepAlive(this.thinking, this.mode);
     }, 2e3);
   }
+  /**
+   * Cleanup resources (call when session is no longer needed)
+   */
+  cleanup = () => {
+    clearInterval(this.keepAliveInterval);
+    this.sessionFoundCallbacks = [];
+    types.logger.debug("[Session] Cleaned up resources");
+  };
   onThinkingChange = (thinking) => {
     this.thinking = thinking;
     this.client.keepAlive(thinking, this.mode);
@@ -104,6 +119,17 @@ class Session {
     this.client.keepAlive(this.thinking, mode);
     this._onModeChange(mode);
   };
+  /**
+   * Called when Claude session ID is discovered or changed.
+   *
+   * This is triggered by the SessionStart hook when:
+   * - Claude starts a new session (fresh start)
+   * - Claude resumes a session (--continue, --resume flags)
+   * - Claude forks a session (/compact, double-escape fork)
+   *
+   * Updates internal state, syncs to API metadata, and notifies
+   * all registered callbacks (e.g., SessionScanner) about the change.
+   */
   onSessionFound = (sessionId) => {
     this.sessionId = sessionId;
     this.client.updateMetadata((metadata) => ({
@@ -111,6 +137,24 @@ class Session {
       claudeSessionId: sessionId
     }));
     types.logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    for (const callback of this.sessionFoundCallbacks) {
+      callback(sessionId);
+    }
+  };
+  /**
+   * Register a callback to be notified when session ID is found/changed
+   */
+  addSessionFoundCallback = (callback) => {
+    this.sessionFoundCallbacks.push(callback);
+  };
+  /**
+   * Remove a session found callback
+   */
+  removeSessionFoundCallback = (callback) => {
+    const index = this.sessionFoundCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.sessionFoundCallbacks.splice(index, 1);
+    }
   };
   /**
    * Clear the current session ID (used by /clear command)
@@ -121,13 +165,18 @@ class Session {
   };
   /**
    * Consume one-time Claude flags from claudeArgs after Claude spawn
-   * Currently handles: --resume (with or without session ID)
+   * Handles: --resume (with or without session ID), --continue
    */
   consumeOneTimeFlags = () => {
     if (!this.claudeArgs) return;
     const filteredArgs = [];
     for (let i = 0; i < this.claudeArgs.length; i++) {
-      if (this.claudeArgs[i] === "--resume") {
+      const arg = this.claudeArgs[i];
+      if (arg === "--continue") {
+        types.logger.debug("[Session] Consumed --continue flag");
+        continue;
+      }
+      if (arg === "--resume") {
         if (i + 1 < this.claudeArgs.length) {
           const nextArg = this.claudeArgs[i + 1];
           if (!nextArg.startsWith("-") && nextArg.includes("-")) {
@@ -139,9 +188,9 @@ class Session {
         } else {
           types.logger.debug("[Session] Consumed --resume flag (no session ID)");
         }
-      } else {
-        filteredArgs.push(this.claudeArgs[i]);
+        continue;
       }
+      filteredArgs.push(arg);
     }
     this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : void 0;
     types.logger.debug(`[Session] Consumed one-time flags, remaining args:`, this.claudeArgs);
@@ -340,31 +389,20 @@ const claudeCliPath = node_path.resolve(node_path.join(types.projectPath(), "scr
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   fs.mkdirSync(projectDir, { recursive: true });
-  const watcher = fs.watch(projectDir);
-  let resolvedSessionId = null;
-  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
-  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
-  watcher.on("change", (event, filename) => {
-    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      types.logger.debug("change", event, filename);
-      const sessionId = filename.replace(".jsonl", "");
-      if (detectedIdsFileSystem.has(sessionId)) {
-        return;
-      }
-      detectedIdsFileSystem.add(sessionId);
-      if (resolvedSessionId) {
-        return;
-      }
-      if (detectedIdsRandomUUID.has(sessionId)) {
-        resolvedSessionId = sessionId;
-        opts.onSessionFound(sessionId);
-      }
-    }
-  });
+  const hasContinueFlag = opts.claudeArgs?.includes("--continue");
+  const hasResumeFlag = opts.claudeArgs?.includes("--resume");
+  const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
     startFrom = null;
   }
+  if (startFrom) {
+    types.logger.debug(`[ClaudeLocal] Will resume existing session: ${startFrom}`);
+  } else if (hasUserSessionControl) {
+    types.logger.debug(`[ClaudeLocal] User passed ${hasContinueFlag ? "--continue" : "--resume"} flag, session ID will be determined by hook`);
+  } else {
+    types.logger.debug(`[ClaudeLocal] Fresh start, session ID will be provided by hook`);
+  }
   let thinking = false;
   let stopThinkingTimeout = null;
   const updateThinking = (newThinking) => {
@@ -381,15 +419,10 @@ async function claudeLocal(opts) {
     if (Object.keys(direnvVars).length > 0) {
       types.logger.debug(`[ClaudeLocal] Loaded ${Object.keys(direnvVars).length} direnv environment variables`);
     }
-    const env = {
-      ...process.env,
-      ...direnvVars,
-      ...opts.claudeEnvVars
-    };
     process.stdin.pause();
     await new Promise((r, reject) => {
       const args = [];
-      if (startFrom) {
+      if (!hasUserSessionControl && startFrom) {
         args.push("--resume", startFrom);
       }
       args.push("--append-system-prompt", systemPrompt);
@@ -402,9 +435,18 @@ async function claudeLocal(opts) {
       if (opts.claudeArgs) {
         args.push(...opts.claudeArgs);
       }
+      args.push("--settings", opts.hookSettingsPath);
+      types.logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
       if (!claudeCliPath || !fs.existsSync(claudeCliPath)) {
         throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
       }
+      const env = {
+        ...process.env,
+        ...direnvVars,
+        ...opts.claudeEnvVars
+      };
+      types.logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      types.logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
       const child = node_child_process.spawn("node", [claudeCliPath, ...args], {
         stdio: ["inherit", "inherit", "inherit", "pipe"],
         signal: opts.abort,
@@ -421,13 +463,6 @@ async function claudeLocal(opts) {
           try {
             const message = JSON.parse(line);
             switch (message.type) {
-              case "uuid":
-                detectedIdsRandomUUID.add(message.value);
-                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
-                  resolvedSessionId = message.value;
-                  opts.onSessionFound(message.value);
-                }
-                break;
               case "fetch-start":
                 activeFetches.set(message.id, {
                   hostname: message.hostname,
@@ -481,7 +516,6 @@ async function claudeLocal(opts) {
       });
     });
   } finally {
-    watcher.close();
     process.stdin.resume();
     if (stopThinkingTimeout) {
       clearTimeout(stopThinkingTimeout);
@@ -489,7 +523,7 @@ async function claudeLocal(opts) {
     }
     updateThinking(false);
   }
-  return resolvedSessionId;
+  return startFrom;
 }
 
 class Future {
@@ -743,21 +777,32 @@ async function claudeLocalLauncher(session) {
       }
     }
   });
+  const scannerSessionCallback = (sessionId) => {
+    scanner.onNewSession(sessionId);
+  };
+  session.addSessionFoundCallback(scannerSessionCallback);
   let exitReason = null;
-  const processAbortController = new AbortController();
+  let abortRequested = false;
+  let processAbortController = new AbortController();
   let exutFuture = new Future();
   try {
+    let getAbortController2 = function() {
+      return processAbortController;
+    }, getExitFuture2 = function() {
+      return exutFuture;
+    };
+    var getAbortController = getAbortController2, getExitFuture = getExitFuture2;
     async function abort() {
-      if (!processAbortController.signal.aborted) {
-        processAbortController.abort();
+      const controller = getAbortController2();
+      const exitFuture = getExitFuture2();
+      if (!controller.signal.aborted) {
+        controller.abort();
       }
-      await exutFuture.promise;
+      await exitFuture.promise;
     }
     async function doAbort() {
       types.logger.debug("[local]: doAbort");
-      if (!exitReason) {
-        exitReason = "switch";
-      }
+      abortRequested = true;
       session.queue.reset();
       await abort();
     }
@@ -795,9 +840,17 @@ async function claudeLocalLauncher(session) {
           claudeEnvVars: session.claudeEnvVars,
           claudeArgs: session.claudeArgs,
           mcpServers: session.mcpServers,
-          allowedTools: session.allowedTools
+          allowedTools: session.allowedTools,
+          hookSettingsPath: session.hookSettingsPath
         });
         session.consumeOneTimeFlags();
+        if (abortRequested) {
+          types.logger.debug("[local]: Aborting current operation, continuing local mode");
+          abortRequested = false;
+          processAbortController = new AbortController();
+          exutFuture = new Future();
+          continue;
+        }
         if (!exitReason) {
           exitReason = "exit";
           break;
@@ -805,6 +858,13 @@ async function claudeLocalLauncher(session) {
       } catch (e) {
         const errorMessage = e instanceof Error ? e.message : String(e);
         types.logger.debug("[local]: launch error", e);
+        if (abortRequested) {
+          types.logger.debug("[local]: Aborting after error, continuing local mode");
+          abortRequested = false;
+          processAbortController = new AbortController();
+          exutFuture = new Future();
+          continue;
+        }
         const reason = exitReason;
         if (reason === "switch") {
           session.client.sendSessionEvent({ type: "message", message: `Error during mode switch: ${errorMessage}` });
@@ -826,6 +886,7 @@ async function claudeLocalLauncher(session) {
     session.client.rpcHandlerManager.registerHandler("switch", async () => {
     });
     session.queue.setOnMessage(null);
+    session.removeSessionFoundCallback(scannerSessionCallback);
     await scanner.cleanup();
   }
   return exitReason || "exit";
@@ -845,6 +906,39 @@ class MessageBuffer {
     this.messages.push(message);
     this.notifyListeners();
   }
+  /**
+   * Update the last message of a specific type by appending content to it
+   * Useful for streaming responses where deltas should accumulate in one message
+   */
+  updateLastMessage(contentDelta, type = "assistant") {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        const oldMessage = this.messages[i];
+        const updatedMessage = {
+          ...oldMessage,
+          content: oldMessage.content + contentDelta
+        };
+        this.messages[i] = updatedMessage;
+        this.notifyListeners();
+        return;
+      }
+    }
+    this.addMessage(contentDelta, type);
+  }
+  /**
+   * Remove the last message of a specific type
+   * Useful for removing placeholder messages like "Thinking..." when actual response starts
+   */
+  removeLastMessage(type) {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        this.messages.splice(i, 1);
+        this.notifyListeners();
+        return true;
+      }
+    }
+    return false;
+  }
   getMessages() {
     return [...this.messages];
   }
@@ -1090,10 +1184,94 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DLt6o6FN.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DGfkEaE6.cjs', document.baseURI).href)));
 const __dirname$1 = node_path.join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: os.homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    types.logger.debug(`[Claude SDK] Global claude --version output: ${output}`);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    const cleanPath = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+    env[actualPathKey] = cleanPath;
+    types.logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = os.homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    node_child_process.execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    types.logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = node_child_process.execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && fs.existsSync(result)) {
+        types.logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function getDefaultClaudeCodePath() {
-  return node_path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  const nodeModulesPath = node_path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    types.logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
+    return process.env.HAPPY_CLAUDE_PATH;
+  }
+  if (process.env.HAPPY_USE_BUNDLED_CLAUDE === "1") {
+    types.logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    types.logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  types.logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    types.logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
@@ -1322,6 +1500,7 @@ function query(config) {
       fallbackModel,
       strictMcpConfig,
       canCallTool,
+      settingsPath,
       onStderr
     } = {}
   } = config;
@@ -1348,6 +1527,7 @@ function query(config) {
   }
   if (strictMcpConfig) args.push("--strict-mcp-config");
   if (permissionMode) args.push("--permission-mode", permissionMode);
+  if (settingsPath) args.push("--settings", settingsPath);
   if (fallbackModel) {
     if (model && fallbackModel === model) {
       throw new Error("Fallback model cannot be the same as the main model. Please specify a different model for fallbackModel option.");
@@ -1870,6 +2050,7 @@ Echo message: ${echoMessage}` : "");
     pathToClaudeCodeExecutable: (() => {
       return node_path.resolve(node_path.join(types.projectPath(), "scripts", "claude_remote_launcher.cjs"));
     })(),
+    settingsPath: opts.hookSettingsPath,
     onStderr: opts.onStderr
   };
   let thinking = false;
@@ -1905,6 +2086,8 @@ Echo message: ${echoMessage}` : "");
   const initialContent = await buildMessageContent(initial.message, initial.mode.imageRefs);
   messages.push({
     type: "user",
+    uuid: node_crypto.randomUUID(),
+    // UUID is required for Claude CLI streaming mode
     message: {
       role: "user",
       content: initialContent
@@ -1949,7 +2132,12 @@ Echo message: ${echoMessage}` : "");
         }
         mode = next.mode;
         const nextContent = await buildMessageContent(next.message, next.mode.imageRefs);
-        messages.push({ type: "user", message: { role: "user", content: nextContent } });
+        messages.push({
+          type: "user",
+          uuid: node_crypto.randomUUID(),
+          // UUID is required for Claude CLI streaming mode
+          message: { role: "user", content: nextContent }
+        });
       }
       if (message.type === "user") {
         const msg = message;
@@ -2097,6 +2285,16 @@ class PermissionHandler {
       } else {
         pending.resolve({ behavior: "deny", message: response.reason || "Plan rejected" });
       }
+    } else if (pending.toolName === "AskUserQuestion") {
+      if (response.approved) {
+        const inputWithAnswers = {
+          ...pending.input,
+          answers: response.answers || {}
+        };
+        pending.resolve({ behavior: "allow", updatedInput: inputWithAnswers });
+      } else {
+        pending.resolve({ behavior: "deny", message: response.reason || "User declined to answer the questions." });
+      }
     } else {
       const result = response.approved ? { behavior: "allow", updatedInput: pending.input || {} } : { behavior: "deny", message: response.reason || `The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.` };
       pending.resolve(result);
@@ -2122,11 +2320,13 @@ class PermissionHandler {
       return { behavior: "allow", updatedInput: input };
     }
     const descriptor = getToolDescriptor(toolName);
-    if (this.permissionMode === "bypassPermissions") {
-      return { behavior: "allow", updatedInput: input };
-    }
-    if (this.permissionMode === "acceptEdits" && descriptor.edit) {
-      return { behavior: "allow", updatedInput: input };
+    if (toolName !== "AskUserQuestion") {
+      if (this.permissionMode === "bypassPermissions") {
+        return { behavior: "allow", updatedInput: input };
+      }
+      if (this.permissionMode === "acceptEdits" && descriptor.edit) {
+        return { behavior: "allow", updatedInput: input };
+      }
     }
     let toolCallId = this.resolveToolCallId(toolName, input);
     if (!toolCallId) {
@@ -2858,6 +3058,7 @@ async function claudeRemoteLauncher(session) {
   let exitReason = null;
   let abortController = null;
   let abortFuture = null;
+  let abortRequested = false;
   async function abort() {
     if (abortController && !abortController.signal.aborted) {
       abortController.abort();
@@ -2866,6 +3067,7 @@ async function claudeRemoteLauncher(session) {
   }
   async function doAbort() {
     types.logger.debug("[remote]: doAbort");
+    abortRequested = true;
     await abort();
   }
   async function doSwitch() {
@@ -3051,6 +3253,7 @@ async function claudeRemoteLauncher(session) {
           path: session.path,
           allowedTools: session.allowedTools ?? [],
           mcpServers: session.mcpServers,
+          hookSettingsPath: session.hookSettingsPath,
           canCallTool: permissionHandler.handleToolCall,
           isAborted: (toolCallId) => {
             return permissionHandler.isAborted(toolCallId);
@@ -3130,16 +3333,30 @@ async function claudeRemoteLauncher(session) {
           signal: abortController.signal
         });
         session.consumeOneTimeFlags();
+        if (abortRequested && abortController.signal.aborted) {
+          types.logger.debug("[remote]: Operation aborted by user, continuing remote mode");
+          session.client.sendSessionEvent({ type: "message", message: "Aborted" });
+          abortRequested = false;
+          continue;
+        }
         if (!exitReason && abortController.signal.aborted) {
           session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
         }
       } catch (e) {
         const errorMessage = e instanceof Error ? e.message : String(e);
         types.logger.debug("[remote]: launch error", e);
+        if (abortRequested) {
+          types.logger.debug("[remote]: Aborting after error, continuing remote mode");
+          session.client.sendSessionEvent({ type: "message", message: "Aborted" });
+          abortRequested = false;
+          continue;
+        }
         if (exitReason === "switch") {
           session.client.sendSessionEvent({ type: "message", message: `Error during mode switch: ${errorMessage}` });
+          break;
         } else if (exitReason === "exit") {
           session.client.sendSessionEvent({ type: "message", message: `Error during exit: ${errorMessage}` });
+          break;
         } else {
           session.client.sendSessionEvent({ type: "message", message: `Process error: ${errorMessage}` });
           continue;
@@ -3208,7 +3425,8 @@ async function loop(opts) {
     messageQueue: opts.messageQueue,
     allowedTools: opts.allowedTools,
     onModeChange: opts.onModeChange,
-    initialPermissionMode: opts.permissionMode
+    initialPermissionMode: opts.permissionMode,
+    hookSettingsPath: opts.hookSettingsPath
   });
   if (opts.onSessionReady) {
     opts.onSessionReady(session);
@@ -3704,6 +3922,139 @@ function extractSDKMetadataAsync(onComplete) {
   });
 }
 
+function parseFrontmatter(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: null, body: content };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const frontmatterStr = trimmed.substring(3, endIndex).trim();
+  const body = trimmed.substring(endIndex + 3).trim();
+  const frontmatter = {};
+  const lines = frontmatterStr.split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.substring(0, colonIndex).trim();
+    let value = line.substring(colonIndex + 1).trim();
+    if (key === "allowed-tools" && value) {
+      frontmatter["allowed-tools"] = value.split(",").map((s) => s.trim());
+    } else if (key === "description") {
+      frontmatter.description = value;
+    } else if (key === "argument-hint") {
+      frontmatter["argument-hint"] = value;
+    } else if (key === "model") {
+      frontmatter.model = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function extractDescriptionFromContent(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("!")) {
+      return trimmed.length > 100 ? trimmed.substring(0, 100) + "..." : trimmed;
+    }
+  }
+  return void 0;
+}
+function findMarkdownFiles(dir, baseDir = dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) {
+    return results;
+  }
+  try {
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = node_path.join(dir, entry);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory()) {
+        const subResults = findMarkdownFiles(fullPath, baseDir);
+        results.push(...subResults);
+      } else if (stat.isFile() && node_path.extname(entry).toLowerCase() === ".md") {
+        const relativePath = fullPath.substring(baseDir.length + 1);
+        const namespace = relativePath.includes("/") ? relativePath.substring(0, relativePath.lastIndexOf("/")) : void 0;
+        results.push({ filePath: fullPath, namespace });
+      }
+    }
+  } catch (error) {
+    types.logger.debug("[customCommands] Error reading directory:", dir, error);
+  }
+  return results;
+}
+function parseCommandFile(filePath, namespace, scope) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const name = node_path.basename(filePath, ".md");
+    const description = frontmatter?.description || extractDescriptionFromContent(body);
+    let allowedTools;
+    if (frontmatter?.["allowed-tools"]) {
+      const at = frontmatter["allowed-tools"];
+      allowedTools = Array.isArray(at) ? at : [at];
+    }
+    return {
+      name,
+      description,
+      argumentHint: frontmatter?.["argument-hint"],
+      allowedTools,
+      model: frontmatter?.model,
+      scope,
+      namespace,
+      filePath,
+      content: body
+    };
+  } catch (error) {
+    types.logger.debug("[customCommands] Error parsing command file:", filePath, error);
+    return null;
+  }
+}
+function discoverCustomCommands(projectDir) {
+  const commands = [];
+  const projectCommandsDir = node_path.join(projectDir, ".claude", "commands");
+  if (fs.existsSync(projectCommandsDir)) {
+    types.logger.debug("[customCommands] Scanning project commands:", projectCommandsDir);
+    const files = findMarkdownFiles(projectCommandsDir);
+    for (const { filePath, namespace } of files) {
+      const command = parseCommandFile(filePath, namespace, "project");
+      if (command) {
+        commands.push(command);
+      }
+    }
+  }
+  const personalCommandsDir = node_path.join(os.homedir(), ".claude", "commands");
+  if (fs.existsSync(personalCommandsDir)) {
+    types.logger.debug("[customCommands] Scanning personal commands:", personalCommandsDir);
+    const files = findMarkdownFiles(personalCommandsDir);
+    for (const { filePath, namespace } of files) {
+      const command = parseCommandFile(filePath, namespace, "personal");
+      if (command) {
+        const existingIndex = commands.findIndex((c) => c.name === command.name);
+        if (existingIndex === -1) {
+          commands.push(command);
+        } else {
+          types.logger.debug(`[customCommands] Skipping personal command "${command.name}" - project command takes precedence`);
+        }
+      }
+    }
+  }
+  types.logger.debug(`[customCommands] Discovered ${commands.length} custom commands`);
+  return commands;
+}
+function commandsToMetadata(commands) {
+  return commands.map((cmd) => ({
+    name: cmd.name,
+    description: cmd.description,
+    argumentHint: cmd.argumentHint,
+    scope: cmd.scope,
+    namespace: cmd.namespace
+  }));
+}
+
 async function daemonPost(path, body) {
   const state = await types.readDaemonState();
   if (!state?.httpPort) {
@@ -5108,6 +5459,110 @@ async function startHappyServer(client) {
   };
 }
 
+async function startHookServer(options) {
+  const { onSessionHook } = options;
+  return new Promise((resolve, reject) => {
+    const server = node_http.createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/hook/session-start") {
+        const timeout = setTimeout(() => {
+          if (!res.headersSent) {
+            types.logger.debug("[hookServer] Request timeout");
+            res.writeHead(408).end("timeout");
+          }
+        }, 5e3);
+        try {
+          const chunks = [];
+          for await (const chunk of req) {
+            chunks.push(chunk);
+          }
+          clearTimeout(timeout);
+          const body = Buffer.concat(chunks).toString("utf-8");
+          types.logger.debug("[hookServer] Received session hook:", body);
+          let data = {};
+          try {
+            data = JSON.parse(body);
+          } catch (parseError) {
+            types.logger.debug("[hookServer] Failed to parse hook data as JSON:", parseError);
+          }
+          const sessionId = data.session_id || data.sessionId;
+          if (sessionId) {
+            types.logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
+            onSessionHook(sessionId, data);
+          } else {
+            types.logger.debug("[hookServer] Session hook received but no session_id found in data");
+          }
+          res.writeHead(200, { "Content-Type": "text/plain" }).end("ok");
+        } catch (error) {
+          clearTimeout(timeout);
+          types.logger.debug("[hookServer] Error handling session hook:", error);
+          if (!res.headersSent) {
+            res.writeHead(500).end("error");
+          }
+        }
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      types.logger.debug(`[hookServer] Started on port ${port}`);
+      resolve({
+        port,
+        stop: () => {
+          server.close();
+          types.logger.debug("[hookServer] Stopped");
+        }
+      });
+    });
+    server.on("error", (err) => {
+      types.logger.debug("[hookServer] Server error:", err);
+      reject(err);
+    });
+  });
+}
+
+function generateHookSettingsFile(port) {
+  const hooksDir = node_path.join(types.configuration.happyHomeDir, "tmp", "hooks");
+  fs.mkdirSync(hooksDir, { recursive: true });
+  const filename = `session-hook-${process.pid}.json`;
+  const filepath = node_path.join(hooksDir, filename);
+  const forwarderScript = node_path.resolve(types.projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const hookCommand = `node "${forwarderScript}" ${port}`;
+  const settings = {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              type: "command",
+              command: hookCommand
+            }
+          ]
+        }
+      ]
+    }
+  };
+  fs.writeFileSync(filepath, JSON.stringify(settings, null, 2));
+  types.logger.debug(`[generateHookSettings] Created hook settings file: ${filepath}`);
+  return filepath;
+}
+function cleanupHookSettingsFile(filepath) {
+  try {
+    if (fs.existsSync(filepath)) {
+      fs.unlinkSync(filepath);
+      types.logger.debug(`[generateHookSettings] Cleaned up hook settings file: ${filepath}`);
+    }
+  } catch (error) {
+    types.logger.debug(`[generateHookSettings] Failed to cleanup hook settings file: ${error}`);
+  }
+}
+
 function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   rpcHandlerManager.registerHandler("killSession", async () => {
     types.logger.debug("Kill session request received");
@@ -5195,6 +5650,20 @@ async function runClaude(credentials, options = {}) {
   } catch (error) {
     types.logger.debug("[START] Failed to report to daemon (may not be running):", error);
   }
+  const customCommands = discoverCustomCommands(workingDirectory);
+  const customCommandsMetadata = commandsToMetadata(customCommands);
+  types.logger.debug(`[start] Discovered ${customCommands.length} custom commands`);
+  if (customCommandsMetadata.length > 0) {
+    try {
+      api.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
+        ...currentMetadata,
+        customCommands: customCommandsMetadata
+      }));
+      types.logger.debug("[start] Session metadata updated with custom commands");
+    } catch (error) {
+      types.logger.debug("[start] Failed to update session metadata with custom commands:", error);
+    }
+  }
   extractSDKMetadataAsync(async (sdkMetadata) => {
     types.logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
     try {
@@ -5211,6 +5680,22 @@ async function runClaude(credentials, options = {}) {
   const session = api.sessionSyncClient(response);
   const happyServer = await startHappyServer(session);
   types.logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
+  let currentSession = null;
+  const hookServer = await startHookServer({
+    onSessionHook: (sessionId, data) => {
+      types.logger.debug(`[START] Session hook received: ${sessionId}`, data);
+      if (currentSession) {
+        const previousSessionId = currentSession.sessionId;
+        if (previousSessionId !== sessionId) {
+          types.logger.debug(`[START] Claude session ID changed: ${previousSessionId} -> ${sessionId}`);
+          currentSession.onSessionFound(sessionId);
+        }
+      }
+    }
+  });
+  types.logger.debug(`[START] Hook server started on port ${hookServer.port}`);
+  const hookSettingsPath = generateHookSettingsFile(hookServer.port);
+  types.logger.debug(`[START] Generated hook settings file: ${hookSettingsPath}`);
   const logPath = types.logger.logFilePath;
   types.logger.infoDeveloper(`Session: ${response.id}`);
   types.logger.infoDeveloper(`Logs: ${logPath}`);
@@ -5374,6 +5859,11 @@ async function runClaude(credentials, options = {}) {
       }
       stopCaffeinate();
       happyServer.stop();
+      hookServer.stop();
+      cleanupHookSettingsFile(hookSettingsPath);
+      if (currentSession) {
+        currentSession.cleanup();
+      }
       types.logger.debug("[START] Cleanup complete, exiting");
       process.exit(0);
     } catch (error) {
@@ -5407,7 +5897,8 @@ async function runClaude(credentials, options = {}) {
         controlledByUser: newMode === "local"
       }));
     },
-    onSessionReady: (_sessionInstance) => {
+    onSessionReady: (sessionInstance) => {
+      currentSession = sessionInstance;
     },
     mcpServers: {
       "happy": {
@@ -5417,7 +5908,8 @@ async function runClaude(credentials, options = {}) {
     },
     session,
     claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs
+    claudeArgs: options.claudeArgs,
+    hookSettingsPath
   });
   session.sendSessionDeath();
   types.logger.debug("Waiting for socket to flush...");
@@ -5428,6 +5920,9 @@ async function runClaude(credentials, options = {}) {
   types.logger.debug("Stopped sleep prevention");
   happyServer.stop();
   types.logger.debug("Stopped Happy MCP server");
+  hookServer.stop();
+  cleanupHookSettingsFile(hookSettingsPath);
+  types.logger.debug("Stopped hook server");
   process.exit(0);
 }
 
@@ -6533,7 +7028,7 @@ async function handleConnectVendor(vendor, displayName) {
     return;
   } else if (subcommand === "codex") {
     try {
-      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CFU1flPl.cjs'); });
+      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-DJSRJ2Pg.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -6578,7 +7073,7 @@ async function handleConnectVendor(vendor, displayName) {
   } else if (subcommand === "list") {
     try {
       const { credentials } = await authAndSetupMachineIfNeeded();
-      const { listSessions } = await Promise.resolve().then(function () { return require('./list-TnYgXXGw.cjs'); });
+      const { listSessions } = await Promise.resolve().then(function () { return require('./list-S3T6MByP.cjs'); });
       let sessionId;
       let titleFilter;
       let recentMsgs;
@@ -6680,7 +7175,7 @@ Examples:
         process.exit(1);
       }
       const { credentials } = await authAndSetupMachineIfNeeded();
-      const { promptSession } = await Promise.resolve().then(function () { return require('./prompt-Cf8Tnep4.cjs'); });
+      const { promptSession } = await Promise.resolve().then(function () { return require('./prompt-5iJXZPz1.cjs'); });
       await promptSession(credentials, sessionId, promptText, timeoutMinutes ?? void 0);
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");