grok-telegram-bot 2.3.1 → 2.4.0

package/.env.example

@@ -85,6 +85,32 @@ PROGRESS_FALLBACK=true
 # session (marked "From other session"). true/false
 NOTIFY_OTHER_SESSIONS=true
 
+# ── Post-turn suggestions ────────────────────────────────────────────────────
+# After a successful Done, quietly ask Grok for 1–3 follow-up steps (JSON with
+# a need score 0–100). Shown as inline buttons on the Done message.
+# SUGGESTIONS_ENABLED=true
+# Auto-queue any suggestion with need ≥ this percent (0 = buttons only, no auto).
+# Default 95. Unrelated suggestions are instructed to score ≤ 60.
+# When several suggestions qualify, they are merged into ONE multi-step prompt:
+#   1) first
+#   2) second
+# SUGGESTIONS_AUTO_APPROVE_PCT=95
+
+# ── Self-recheck (once per user prompt, gated) ───────────────────────────────
+# After a successful user turn (queue empty), the bot may run one quality pass.
+# Flow:
+#   1) Skip automatically if no files were modified this turn.
+#   2) Quiet meta ask: should we recheck? AI may refuse (simple tasks, pure
+#      build/install, nothing worth re-verifying).
+#   3) If needed, AI writes a focused recheck prompt; that prompt is submitted
+#      as the one-shot self-recheck turn (may use tools to fix real issues).
+#   4) Only then: Done + suggestions (Done splits first-turn vs recheck files).
+# Default true. Alias: SLEF_RECHECK (typo-tolerant).
+# SELF_RECHECK=true
+# Optional: when set AND the AI decides recheck is needed, use this template
+# instead of the AI-written recheck body ({{USER}} / {{DONE}} placeholders).
+# SELF_RECHECK_PROMPT=
+
 # ── MCP servers (/mcp) ───────────────────────────────────────────────────────
 # /mcp lists MCP servers the bot can discover and health-checks them. Grok Build
 # manages its own MCP servers via `grok`'s /mcps modal and ~/.grok/config.toml,

package/CHANGELOG.md

@@ -9,6 +9,42 @@ The latest section is published verbatim as the GitHub Release notes by
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-08-01
+
+### Added
+
+- **Post-turn suggestions.** After Done, quietly ask for 1–3 follow-ups with a
+  need score (0–100). Shown as inline buttons; items at/above
+  `SUGGESTIONS_AUTO_APPROVE_PCT` (default 95) run as **one** numbered multi-step
+  prompt (`1) …\n2) …`).
+- **Gated self-recheck.** After a successful user turn with file changes, a
+  quiet AI decision may refuse recheck (simple tasks / pure build) or write a
+  focused recheck prompt that runs once before Done. Skipped when no files
+  modified. Env: `SELF_RECHECK` / `SLEF_RECHECK`, optional `SELF_RECHECK_PROMPT`.
+- **Auto complexity steering.** First prompt of a session steers Simple vs
+  Complex without asking the user; plan-mode exit is auto-approved
+  (`_x.ai/exit_plan_mode`).
+- **Plan board rendering.** Live plan entries with progress in the status stream.
+- **Session import.** Import external session transcripts into a bot-controlled
+  session.
+- **Richer tool / file / markdown rendering.** Improved tool-call detail, file
+  op summaries (including first-turn vs recheck split), session card comments,
+  and Markdown fence safety.
+- **Usage / accounts menu polish.** Clearer usage and account surfaces in the
+  Telegram menu.
+
+### Fixed / hardened
+
+- **Near-100% bot lifetime.** Telegram long-poll restarts forever; uncaught
+  errors stay up; ACP and `createBot` boot retries; lock heartbeat; Windows VBS
+  forever-restart supervisor; stop kills the VBS host; self-relaunch / updater
+  stay alive if spawn fails.
+- **Self-recheck / queue safety.** `mergeInputs` preserves `skipSelfRecheck`;
+  meta turns flush alone so auto-batches cannot re-arm recheck loops; cancel
+  during recheck decision does not queue a recheck.
+- **Plan exit reliability.** Correct ACP method and approval payload for plan
+  mode exit.
+
 ## [2.3.1] - 2026-07-19
 
 ### Fixed
@@ -778,6 +814,7 @@ from a single chat and switch between them, on a redesigned, compact menu.
   diffs, MarkdownV2 rendering, scheduled tasks, multi-image prompts, and a
   cross-platform 24/7 background service.
 
+[2.4.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.4.0
 [2.3.1]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.1
 [2.3.0]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.3.0
 [2.2.4]: https://github.com/artickc/grok-telegram-bot/releases/tag/v2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Control the official Grok Build CLI from Telegram over the Agent Client Protocol (ACP). Sign in with your xAI account, switch projects, resume sessions, stream responses with diffs, queue follow-ups, manage multiple sign-ins, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",

package/scripts/analyze-jsonl.ts

@@ -0,0 +1,33 @@
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+
+const path = process.argv[2];
+if (!path) {
+  console.error("usage: analyze-jsonl <path>");
+  process.exit(1);
+}
+
+const kinds = new Map<string, number>();
+let lines = 0;
+let bad = 0;
+
+const rl = createInterface({ input: createReadStream(path, { encoding: "utf8" }) });
+for await (const line of rl) {
+  if (!line.trim()) continue;
+  lines++;
+  try {
+    const o = JSON.parse(line) as { kind?: string; type?: string };
+    const k = o.kind || o.type || "(none)";
+    kinds.set(k, (kinds.get(k) || 0) + 1);
+  } catch {
+    bad++;
+  }
+}
+
+console.log(JSON.stringify({ path, lines, bad }, null, 2));
+console.log(
+  [...kinds.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([k, n]) => `${n}\t${k}`)
+    .join("\n"),
+);

package/scripts/delayed-restart.ps1

@@ -0,0 +1,29 @@
+Set-Location "H:\Lucru\Domains\grok-telegram-bot"
+$log = "H:\Lucru\Domains\grok-telegram-bot\logs\restart-verify.log"
+function W($m) { $line = "$(Get-Date -Format o) $m"; Add-Content -Path $log -Value $line; Write-Output $line }
+
+W "waiting 20s for idle/flush..."
+Start-Sleep -Seconds 20
+
+$old = Get-CimInstance Win32_Process -Filter "name='node.exe'" | Where-Object { $_.CommandLine -match 'grok-telegram-bot\\src\\index' } | Select-Object -ExpandProperty ProcessId
+W "old pid(s): $($old -join ',')"
+
+W "running: npx tsx src/cli.ts restart"
+$out = npx tsx src/cli.ts restart 2>&1 | Out-String
+W $out
+
+Start-Sleep -Seconds 8
+$new = Get-CimInstance Win32_Process -Filter "name='node.exe'" | Where-Object { $_.CommandLine -match 'grok-telegram-bot\\src\\index' } | Select-Object ProcessId,CreationDate,CommandLine
+W "new process:"
+W ($new | Format-List | Out-String)
+
+# Confirm loaded code path mentions outcome approved by checking process start after our file mtime
+$fixMtime = (Get-Item "H:\Lucru\Domains\grok-telegram-bot\src\grok\plan-approval.ts").LastWriteTime
+W "plan-approval.ts mtime: $fixMtime"
+if ($new) {
+  W "status:"
+  W (npx tsx src/cli.ts status 2>&1 | Out-String)
+  W "RESTART_OK"
+} else {
+  W "RESTART_FAILED no process"
+}

package/scripts/probe-exit-response-shape.py

@@ -0,0 +1,77 @@
+"""Deep probe of grok.exe for ExitPlanMode reverse-request/response shapes."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+data = Path(r"C:\Users\artic\.grok\bin\grok.exe").read_bytes()
+
+
+def nearby(label: bytes, n: int = 3, before: int = 120, after: int = 300) -> None:
+    start = 0
+    for i in range(n):
+        j = data.find(label, start)
+        if j < 0:
+            print(f"NOT FOUND: {label!r}")
+            return
+        chunk = data[max(0, j - before) : j + after]
+        text = "".join(chr(b) if 32 <= b < 127 else "|" for b in chunk)
+        print(f"\n=== {label!r} @{j} ===\n{text}")
+        start = j + len(label)
+
+
+# Key messages around reverse-request
+for lab in [
+    b"sending ext_method to client",
+    b"client disconnected mid-approval",
+    b"no client wired",
+    b"ExitPlanModeExtRequest",
+    b"ExitPlanModeExtResponse",
+    b"Failed to parse ExitPlanMode",
+    b"x.ai/exit_plan_mode",
+    b"agent.ext_method",
+    b"ext_method",
+    b"session/request_permission",
+]:
+    nearby(lab, n=2)
+
+print("\n\n==== null-terminated strings containing ExitPlan or approved near ExtResponse ====")
+idx = data.find(b"ExitPlanModeExtResponse serialization")
+region = data[max(0, idx - 4000) : idx + 2000]
+cur = bytearray()
+strs: list[str] = []
+for b in region:
+    if 32 <= b < 127:
+        cur.append(b)
+    else:
+        if 3 <= len(cur) <= 60:
+            s = cur.decode()
+            if any(
+                k in s.lower()
+                for k in (
+                    "approv",
+                    "abandon",
+                    "feedback",
+                    "decision",
+                    "action",
+                    "outcome",
+                    "plan",
+                    "comment",
+                    "exit",
+                    "request",
+                    "session",
+                    "content",
+                )
+            ):
+                strs.append(s)
+        cur.clear()
+for s in dict.fromkeys(strs):
+    print(repr(s))
+
+print("\n\n==== method name candidates ====")
+for m in sorted(set(re.findall(rb"x\.ai/[a-zA-Z0-9_/\-]{3,50}", data))):
+    s = m.decode("ascii", "ignore")
+    if any(k in s.lower() for k in ("plan", "exit", "ask", "approv", "question")):
+        # only print clean-looking
+        if re.fullmatch(r"x\.ai/[a-z0-9_/\-]+", s):
+            print(s)

package/scripts/probe-plan-exit.py

@@ -0,0 +1,60 @@
+"""Probe grok.exe for ExitPlanMode ACP extension request/response shape."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+path = Path(r"C:\Users\artic\.grok\bin\grok.exe")
+data = path.read_bytes()
+
+
+def ctx(idx: int, before: int = 80, after: int = 200) -> str:
+    chunk = data[max(0, idx - before) : idx + after]
+    return "".join(chr(b) if 32 <= b < 127 else "|" for b in chunk)
+
+
+needles = [
+    b"ExitPlanModeExtRequest",
+    b"ExitPlanModeExtResponse",
+    b"Failed to parse ExitPlanModeExtRequest",
+    b"x.ai/exit_plan_mode",
+    b"[exit_plan_mode] user approved",
+    b"[exit_plan_mode] user abandoned",
+    b"request_changes",
+    b"requestChanges",
+    b"additionalFeedback",
+    b"additional_feedback",
+    b"planContent",
+    b"plan_content",
+    b"emptyPlan",
+    b"EmptyPlan",
+    b"PlanReady",
+]
+
+for n in needles:
+    i = 0
+    c = 0
+    while c < 3:
+        j = data.find(n, i)
+        if j < 0:
+            break
+        print(f"\n=== {n!r} @ {j} ===")
+        print(ctx(j, 40, 160))
+        i = j + len(n)
+        c += 1
+
+print("\n=== combos approved/abandoned ===")
+for m in re.finditer(rb"approved.{0,30}abandoned|abandoned.{0,30}approved", data, re.I):
+    print(ctx(m.start(), 10, 80))
+
+print("\n=== identifiers near first ExtResponse ===")
+idx = data.find(b"ExitPlanModeExtResponse")
+if idx >= 0:
+    region = data[idx : idx + 1200]
+    print(re.findall(rb"[A-Za-z_][A-Za-z0-9_]{2,40}", region)[:60])
+
+print("\n=== identifiers near struct ExitPlanModeExtRequest with 3 ===")
+idx = data.find(b"struct ExitPlanModeExtRequest with 3 elements")
+if idx >= 0:
+    region = data[idx - 400 : idx + 400]
+    print([s.decode() for s in re.findall(rb"[A-Za-z_][A-Za-z0-9_]{2,40}", region)])

package/scripts/probe-plan-exit2.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+import re
+
+data = Path(r"C:\Users\artic\.grok\bin\grok.exe").read_bytes()
+
+# Pull null-terminated strings of length 3-40 around key anchors
+anchors = [
+    data.find(b"ExitPlanModeExtRequest serialization"),
+    data.find(b"ExitPlanModeExtResponse serialization"),
+    data.find(b"struct ExitPlanModeExtRequest with 3"),
+    data.find(b"struct ExitPlanModeExtResponse with 2"),
+    data.find(b"approvedabandonedAdditional feedback"),
+    data.find(b"[exit_plan_mode] intercepted"),
+    data.find(b"Plan approval requested"),
+]
+
+for a in anchors:
+    if a < 0:
+        continue
+    region = data[max(0, a - 800) : a + 800]
+    strs = []
+    cur = bytearray()
+    for b in region:
+        if 32 <= b < 127:
+            cur.append(b)
+        else:
+            if 3 <= len(cur) <= 48:
+                strs.append(cur.decode("ascii"))
+            cur.clear()
+    if 3 <= len(cur) <= 48:
+        strs.append(cur.decode("ascii"))
+    # unique preserve order
+    seen = set()
+    out = []
+    for s in strs:
+        if s not in seen:
+            seen.add(s)
+            out.append(s)
+    print("\n==== ANCHOR", a, "====")
+    for s in out:
+        print(s)
+
+# Also list method names that look like reverse requests
+print("\n==== x.ai methods clean ====")
+for m in sorted(set(re.findall(rb"x\.ai/[a-z0-9_/\-]{3,60}", data))):
+    s = m.decode()
+    if any(k in s for k in ["plan", "ask", "question", "mode", "approv"]):
+        print(s)

package/scripts/probe-plan-fields.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+import re
+
+data = Path(r"C:\Users\artic\.grok\bin\grok.exe").read_bytes()
+
+for n in [
+    b"additional_feedback",
+    b"additionalFeedback",
+    b"AdditionalFeedback",
+    b"review_comments",
+    b"reviewComments",
+]:
+    print(n, "count", data.count(n), "at", data.find(n))
+
+# Pull short identifiers within 2KB of ExitPlanModeExtResponse serialization
+idx = data.find(b"ExitPlanModeExtResponse serialization")
+region = data[idx - 2000 : idx + 500]
+idents = re.findall(rb"[A-Za-z_][A-Za-z0-9_]{2,40}", region)
+# filter boring
+skip = {"struct", "with", "elements", "serialization", "should", "not", "fail", "crates", "codegen"}
+seen = []
+for s in idents:
+    t = s.decode()
+    if t in skip or t in seen:
+        continue
+    seen.append(t)
+print("idents near serialization:", seen[:80])
+
+# Look for schemars / json schema around ExitPlanModeExt
+for pat in [rb'"decision"', rb'"action"', rb'"outcome"', rb'"approved"', rb'"abandoned"']:
+    c = 0
+    start = 0
+    while c < 5:
+        j = data.find(pat, start)
+        if j < 0:
+            break
+        window = data[j : j + 80]
+        if b"plan" in window.lower() or b"approv" in window or b"abandon" in window:
+            print(pat, j, window[:80])
+            c += 1
+        start = j + 1

package/scripts/probe-plan-fields2.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+import re
+
+data = Path(r"C:\Users\artic\.grok\bin\grok.exe").read_bytes()
+
+# Find null-separated sequences containing approved and abandoned as siblings
+needle = b"approved\x00abandoned"
+idx = data.find(needle)
+print("approved\\0abandoned", idx)
+if idx >= 0:
+    print(data[idx - 40 : idx + 80])
+
+needle2 = b"abandoned\x00approved"
+print("abandoned\\0approved", data.find(needle2))
+
+# Also try without null (concatenated variants for Display)
+print("concat", data.find(b"approvedabandoned"))
+
+# Search for field name candidates near concat
+idx = data.find(b"approvedabandoned")
+region = data[idx - 100 : idx + 120]
+# extract C strings
+cur = bytearray()
+strs = []
+for b in region:
+    if 32 <= b < 127:
+        cur.append(b)
+    else:
+        if cur:
+            strs.append(cur.decode())
+            cur.clear()
+print("near concat:", strs)
+
+# Look at ExitPlanModeExtRequest 3 elements - field names for request
+for label in [b"plan_content", b"plan_file_path", b"session_id", b"sessionId", b"tool_call_id", b"toolCallId", b"empty"]:
+    print(label, data.count(label))
+
+# Find bytes: decision\0 or action\0 near approved
+for field in [b"decision\x00", b"action\x00", b"outcome\x00", b"result\x00", b"choice\x00", b"feedback\x00", b"comments\x00", b"message\x00"]:
+    start = 0
+    hits = 0
+    while hits < 3:
+        j = data.find(field, start)
+        if j < 0:
+            break
+        win = data[j : j + 60]
+        if b"approv" in win or b"abandon" in win or b"plan" in win.lower():
+            print("FIELD", field, j, win)
+            hits += 1
+        start = j + 1
+
+# Extract all strings of form [a-z_]+ that appear within 200 bytes after "ExitPlanModeExtResponse with 2"
+idx = data.find(b"struct ExitPlanModeExtResponse with 2 elements")
+print("struct at", idx)
+if idx >= 0:
+    region = data[idx : idx + 300]
+    print(region)
+    print(re.findall(rb"[a-z_]{3,30}", region))

package/scripts/probe-plan-response-path.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+data = Path(r"C:\Users\artic\.grok\bin\grok.exe").read_bytes()
+
+
+def show(label: bytes, n: int = 3, before: int = 100, after: int = 250) -> None:
+    start = 0
+    for _ in range(n):
+        j = data.find(label, start)
+        if j < 0:
+            print(label, "not found")
+            return
+        chunk = data[max(0, j - before) : j + after]
+        text = "".join(chr(b) if 32 <= b < 127 else "|" for b in chunk)
+        print(f"\n=== {label!r} @ {j} ===")
+        print(text)
+        start = j + len(label)
+
+
+for lab in [
+    b"[exit_plan_mode] user approved",
+    b"[exit_plan_mode] user abandoned",
+    b"Opened plan approval view from ext_method",
+    b"Failed to parse ExitPlanModeExtResponse",
+    b"ExitPlanModeExtResponse serialization should not fail",
+    b"resume exit_plan_mode reverse-request failed",
+    b"Plan approval requested",
+]:
+    show(lab, n=2)
+
+# Print unique printable strings of length 4-24 in a 1KB window after
+# "Opened plan approval view from ext_method"
+idx = data.find(b"Opened plan approval view from ext_method")
+region = data[idx : idx + 1500]
+cur = bytearray()
+seen = []
+for b in region:
+    if 32 <= b < 127:
+        cur.append(b)
+    else:
+        if 4 <= len(cur) <= 32:
+            s = cur.decode()
+            if s not in seen:
+                seen.append(s)
+        cur.clear()
+print("\nstrings after open plan approval:")
+for s in seen:
+    print(" ", s)

package/scripts/sample-claude-tooluse.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+
+const path =
+  "H:\\Lucru\\Domains\\claude-telegram-bot\\data\\sessions\\019f47bc-67bc-7043-a40a-f487a1d5af8b.jsonl";
+const lines = readFileSync(path, "utf8").split(/\n/).filter(Boolean);
+
+for (const line of lines) {
+  const o = JSON.parse(line) as { kind?: string; data?: Record<string, unknown> };
+  if (o.kind === "ToolUse") {
+    console.log("keys", Object.keys(o.data || {}));
+    console.log(JSON.stringify(o).slice(0, 1500));
+    break;
+  }
+}
+for (const line of lines) {
+  const o = JSON.parse(line) as { kind?: string };
+  if (o.kind === "AssistantMessage") {
+    console.log("ASSIST", JSON.stringify(o).slice(0, 800));
+    break;
+  }
+}

package/scripts/sample-kiro-events.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const path = join(homedir(), ".kiro", "sessions", "cli", "8d37ff05-4658-4e7c-be14-3693e1c82d00.jsonl");
+const lines = readFileSync(path, "utf8").split(/\n/).filter(Boolean);
+
+for (const line of lines) {
+  const o = JSON.parse(line) as { kind?: string; data?: { content?: unknown; results?: unknown } };
+  if (o.kind === "ToolResults") {
+    console.log("TOOLRESULTS data keys", o.data ? Object.keys(o.data) : []);
+    console.log(JSON.stringify(o.data).slice(0, 1200));
+    break;
+  }
+}
+for (const line of lines) {
+  const o = JSON.parse(line) as { kind?: string; data?: { content?: unknown } };
+  if (o.kind === "AssistantMessage" && JSON.stringify(o).includes("toolUse")) {
+    console.log("ASSIST toolUse content");
+    console.log(JSON.stringify(o.data?.content).slice(0, 1200));
+    break;
+  }
+}
+for (const line of lines) {
+  const o = JSON.parse(line) as { kind?: string; data?: { content?: unknown } };
+  if (o.kind === "AssistantMessage" && JSON.stringify(o).includes("thinking")) {
+    console.log("ASSIST thinking content");
+    console.log(JSON.stringify(o.data?.content).slice(0, 800));
+    break;
+  }
+}