Rework hooks to notification-only: no blocking, terminal still works

- on-stuck.sh: sends TG notification when AskUserQuestion fires, passes through
- on-approve.sh: sends TG notification for tool uses (Bash/Edit/Write), passes through
- Both hooks run notify in background (fire-and-forget) so terminal is never blocked
- Add `prompt` command to index.js (inline keyboard support for future use)
- Update telegram-recv to also handle callback_query updates
- User can approve/answer from terminal OR Telegram — both work

Author: turinglabsorg

CLAUDE.md

@@ -43,13 +43,12 @@ A `PreToolUse` hook intercepts `AskUserQuestion` calls:
 1. Claude gets stuck and tries to ask a question
 2. Hook (`~/.claude/tools/grog/hooks/on-stuck.sh`) intercepts it
 3. Question is sent to Telegram via `grog notify` (includes folder name + full path)
-4. Hook calls `telegram-recv` and waits ~90s for the user's reply
-5. If reply arrives: hook returns it in the `reason` field → Claude continues with the answer
-6. If no reply: hook tells Claude to make its best judgment and keep working
+4. Hook passes through — the terminal prompt still works normally
+5. User can answer in the terminal OR on Telegram
 
-Fully bidirectional — Claude never stops, never needs to manually call `telegram-recv`.
+A second hook (`on-approve.sh`) fires for all tool uses (Bash, Edit, Write, etc.) and sends a notification with tool details. The terminal approval prompt still works normally — notifications are informational.
 
-**Requirement:** `telegramBotToken` and `telegramChatId` must be set in `~/.grog/config.json`. If not configured, the hook passes through and `AskUserQuestion` works normally.
+**Requirement:** `telegramBotToken` and `telegramChatId` must be set in `~/.grog/config.json`. If not configured, both hooks pass through silently and everything works normally.
 
 ## CLI Commands (index.js)
 

skill/hooks/on-approve.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# Grog Hook: on-approve (notification only)
+# Sends a Telegram notification when Claude wants to use a tool that
+# would normally require terminal approval. Does NOT block — the
+# terminal yes/no prompt still works normally.
+#
+# Hook type: PreToolUse (no matcher = catches all tools)
+
+GROG_TOOL="$HOME/.claude/tools/grog/index.js"
+GROG_CONFIG="$HOME/.grog/config.json"
+
+# Read the tool input from stdin
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // "unknown"')
+
+# Skip tools that are always safe / read-only / handled elsewhere
+case "$TOOL_NAME" in
+  Read|Glob|Grep|LSP|WebSearch|WebFetch|Agent|TodoRead|TaskGet|TaskList|TaskOutput|AskUserQuestion)
+    exit 0
+    ;;
+esac
+
+# Check if Telegram is configured
+if [ ! -f "$GROG_CONFIG" ]; then
+  exit 0
+fi
+
+HAS_TOKEN=$(jq -r '.telegramBotToken // empty' "$GROG_CONFIG" 2>/dev/null)
+HAS_CHAT=$(jq -r '.telegramChatId // empty' "$GROG_CONFIG" 2>/dev/null)
+
+if [ -z "$HAS_TOKEN" ] || [ -z "$HAS_CHAT" ]; then
+  exit 0
+fi
+
+# Build a concise summary
+case "$TOOL_NAME" in
+  Bash)
+    DETAIL=$(echo "$INPUT" | jq -r '.tool_input.command // "(no command)"' | head -c 300)
+    SUMMARY="$DETAIL"
+    ;;
+  Edit)
+    FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // "?"')
+    SUMMARY="Edit $FILE"
+    ;;
+  Write)
+    FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // "?"')
+    SUMMARY="Write $FILE"
+    ;;
+  *)
+    SUMMARY=$(echo "$INPUT" | jq -r '.tool_input | keys | join(", ")' 2>/dev/null || echo "$TOOL_NAME")
+    ;;
+esac
+
+CWD=$(pwd)
+FOLDER=$(basename "$CWD")
+
+# Send notification in background (fire-and-forget)
+node "$GROG_TOOL" notify "🔧 [$FOLDER] $TOOL_NAME
+$SUMMARY" >/dev/null 2>&1 &
+
+# Exit 0 = pass through, terminal prompt still works
+exit 0

skill/hooks/on-stuck.sh

@@ -1,11 +1,10 @@
 #!/bin/bash
 
-# Grog Hook: on-stuck (bidirectional)
-# Intercepts AskUserQuestion → sends to Telegram → waits for reply → returns answer to Claude.
+# Grog Hook: on-stuck (notification only)
+# Sends a Telegram notification when Claude calls AskUserQuestion.
+# Does NOT block — the terminal prompt still works normally.
 #
 # Hook type: PreToolUse (matcher: AskUserQuestion)
-# Input: JSON on stdin with tool_input containing the question
-# Output: JSON with decision to block + the Telegram response as context
 
 GROG_TOOL="$HOME/.claude/tools/grog/index.js"
 GROG_CONFIG="$HOME/.grog/config.json"
@@ -28,27 +27,14 @@ if [ -z "$HAS_TOKEN" ] || [ -z "$HAS_CHAT" ]; then
   exit 0
 fi
 
-# Get current working directory for context
 CWD=$(pwd)
 FOLDER=$(basename "$CWD")
 
-# Send question to Telegram with folder context
+# Send notification in background (fire-and-forget) so we don't block the terminal
 node "$GROG_TOOL" notify "🔔 Claude is stuck in [$FOLDER]
 📁 $CWD
 
-$QUESTION
+$QUESTION" >/dev/null 2>&1 &
 
-Reply here to answer." 2>/dev/null
-
-# Wait for response (one attempt, ~90s)
-RESPONSE=$(node "$GROG_TOOL" telegram-recv 2>/dev/null)
-
-if [ "$RESPONSE" = "[no message]" ] || [ -z "$RESPONSE" ]; then
-  # No reply — block and tell Claude to state the blocker and continue without an answer
-  ESCAPED=$(echo "No response from Telegram after ~90s. State the blocker clearly in the terminal output, then make your best judgment call and continue working. Do NOT call AskUserQuestion again for the same question." | jq -Rs .)
-  echo "{\"decision\":\"block\",\"reason\":$ESCAPED}"
-else
-  # Got a reply — pass it back to Claude as context
-  ESCAPED=$(echo "Telegram response from the user: $RESPONSE" | jq -Rs .)
-  echo "{\"decision\":\"block\",\"reason\":$ESCAPED}"
-fi
+# Exit 0 = pass through, terminal prompt still works
+exit 0

skill/index.js

@@ -1338,6 +1338,137 @@ async function handleNotify(args) {
   console.log("> notified via Telegram");
 }
 
+/**
+ * Send a prompt with inline keyboard buttons to Telegram and wait for response.
+ * Used for tool approval (Yes/Yes Always/No) and questions (with Reply option).
+ * Returns the callback data or typed text response.
+ */
+async function handlePrompt(args) {
+  const chatId = TELEGRAM_CHAT_ID;
+
+  if (!chatId) {
+    console.error("! error: TELEGRAM_CHAT_ID not set");
+    process.exit(1);
+  }
+
+  const message = args.join(" ");
+  if (!message) {
+    console.error("! error: empty message");
+    process.exit(1);
+  }
+
+  // Initialize state file if needed
+  const state = loadTelegramState();
+  if (!state.chatId) {
+    const flush = await telegramApi("getUpdates", { timeout: 0 });
+    const offset = flush.length > 0
+      ? Math.max(...flush.map((u) => u.update_id)) + 1
+      : 0;
+    saveTelegramState({ offset, chatId });
+  }
+
+  // Send message with inline keyboard
+  await telegramApi("sendMessage", {
+    chat_id: chatId,
+    text: message,
+    reply_markup: {
+      inline_keyboard: [
+        [
+          { text: "Yes", callback_data: "yes" },
+          { text: "Yes, don't ask again", callback_data: "always" },
+          { text: "No", callback_data: "no" },
+        ],
+        [
+          { text: "Reply with text...", callback_data: "reply" },
+        ],
+      ],
+    },
+  });
+
+  // Wait for callback_query or text message response (~90s)
+  const freshState = loadTelegramState();
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const params = {
+      timeout: 45,
+      allowed_updates: ["callback_query", "message"],
+    };
+    if (freshState.offset) params.offset = freshState.offset;
+
+    const updates = await telegramApi("getUpdates", params);
+
+    // Advance offset for ALL updates
+    if (updates.length > 0) {
+      freshState.offset = Math.max(...updates.map((u) => u.update_id)) + 1;
+      saveTelegramState(freshState);
+    }
+
+    // Check for callback query (button press) from our chat
+    const callback = updates.find(
+      (u) => u.callback_query && String(u.callback_query.message?.chat?.id) === String(chatId),
+    );
+
+    if (callback) {
+      const data = callback.callback_query.data;
+
+      // Acknowledge the callback to remove the loading spinner
+      await telegramApi("answerCallbackQuery", {
+        callback_query_id: callback.callback_query.id,
+      });
+
+      if (data === "reply") {
+        // User wants to type a response — send a follow-up and wait for text
+        await telegramApi("sendMessage", {
+          chat_id: chatId,
+          text: "Type your response:",
+          reply_markup: { force_reply: true },
+        });
+
+        // Wait for the text message
+        for (let textAttempt = 0; textAttempt < 2; textAttempt++) {
+          const textParams = { timeout: 45, allowed_updates: ["message"] };
+          if (freshState.offset) textParams.offset = freshState.offset;
+
+          const textUpdates = await telegramApi("getUpdates", textParams);
+
+          if (textUpdates.length > 0) {
+            freshState.offset = Math.max(...textUpdates.map((u) => u.update_id)) + 1;
+            saveTelegramState(freshState);
+          }
+
+          const textMsg = textUpdates.find(
+            (u) => u.message && String(u.message.chat.id) === String(chatId),
+          );
+
+          if (textMsg) {
+            console.log(`reply:${textMsg.message.text || ""}`);
+            return;
+          }
+        }
+
+        console.log("[no message]");
+        return;
+      }
+
+      // Button press: yes, always, no
+      console.log(data);
+      return;
+    }
+
+    // Check for regular text message (user typed instead of pressing button)
+    const textMsg = updates.find(
+      (u) => u.message && String(u.message.chat.id) === String(chatId),
+    );
+
+    if (textMsg) {
+      console.log(`reply:${textMsg.message.text || ""}`);
+      return;
+    }
+  }
+
+  console.log("[no message]");
+}
+
 /**
  * Wait for a message from Telegram — long-polls for ~90 seconds
  */
@@ -1352,14 +1483,15 @@ async function handleTelegramRecv() {
 
   // Poll with retry — up to ~90 seconds before returning [no message]
   for (let attempt = 0; attempt < 2; attempt++) {
-    const params = { timeout: 45, allowed_updates: ["message"] };
+    const params = { timeout: 45, allowed_updates: ["message", "callback_query"] };
     if (state.offset) params.offset = state.offset;
 
     const updates = await telegramApi("getUpdates", params);
 
-    // Filter for our chat only
+    // Filter for our chat only (messages and callback queries)
     const messages = updates.filter(
-      (u) => u.message && String(u.message.chat.id) === String(chatId),
+      (u) => (u.message && String(u.message.chat.id) === String(chatId)) ||
+             (u.callback_query && String(u.callback_query.message?.chat?.id) === String(chatId)),
     );
 
     // Advance offset for ALL updates (including other chats)
@@ -1370,7 +1502,13 @@ async function handleTelegramRecv() {
 
     if (messages.length > 0) {
       const texts = messages
-        .map((u) => u.message.text || "[non-text message]")
+        .map((u) => {
+          if (u.callback_query) {
+            telegramApi("answerCallbackQuery", { callback_query_id: u.callback_query.id }).catch(() => {});
+            return u.callback_query.data;
+          }
+          return u.message.text || "[non-text message]";
+        })
         .join("\n");
       console.log(texts);
       return;
@@ -1479,6 +1617,17 @@ async function main() {
       break;
     }
 
+    case "prompt": {
+      const promptArgs = process.argv.slice(3);
+      if (promptArgs.length === 0) {
+        console.error("! error: missing message");
+        console.log("  usage: grog prompt <message>");
+        process.exit(1);
+      }
+      await handlePrompt(promptArgs);
+      break;
+    }
+
     default:
       // Backwards compatibility: if the argument looks like a URL, auto-detect command
       if (command.includes("github.com") && command.includes("/issues/")) {