fix: acknowledge approval/clarify/cancel responses in Telegram and WebUI

- Clarify: echo user's choice ('Yes'/'No') instead of generic 'Got it, thanks!'
- Approval: AnswerCallbackQuery now shows toast (Approved/Denied/Trusted)
- WebUI: send approval_ack event after user responds for UI feedback
- Cancel: approvers now listen for Cancel() to interrupt blocking PromptCommand
  (fixes 120s hang when /stop fires during approval)
- Cancel path: send cancellation summary instead of silent return
  (partial session saved + stop summary + recovery hint)
- WebSocket disconnect: approver.Cancel() called to release pending approvals
- New: TelegramApprover.Cancel(), wsApprover.Cancel() (idempotent)
- New: approvalToast() helper in handler.go
- Tests: Cancel interrupts PromptCommand, idempotent, ack not sent on cancel

Author: molty3000

cmd/odek/serve.go

@@ -303,6 +303,9 @@ func handleWS(store *session.Store, resources *resource.Registry, resolved confi
 		return
 	}
 	defer agent.Close()
+	if approver != nil {
+		defer approver.Cancel() // release any pending approval on disconnect
+	}
 	if sandboxCleanup != nil {
 		defer sandboxCleanup()
 	}

cmd/odek/telegram.go

@@ -392,7 +392,7 @@ func telegramCmd(args []string) error {
 					// Channel full or closed — clarify already resolved.
 				}
 			}
-			return "✅ Got it, thanks!", nil
+			return "✅ You chose **" + answer + "**", nil
 		}
 
 		// Route skill suggestion callbacks — Save or Skip.
@@ -1228,15 +1228,23 @@ func handleChatMessage(
 			traceMsgID = 0
 		}
 
-		// If the context was cancelled (by /stop or restart), don't send
-		// a redundant error message — the canceller already notified the
-		// user with a summary or restart notification.
+		// If the context was cancelled (by /stop or restart), save partial
+		// state and notify the user with a cancellation summary.
 		if errors.Is(err, context.Canceled) {
 			// Save partial session state so the conversation isn't lost.
 			cs.LastActive = time.Now()
 			if saveErr := sessionManager.Save(chatID, cs.Messages); saveErr != nil {
 				log.Error("save session after cancel", "chat_id", chatID, "error", saveErr)
 			}
+			// Send a cancellation summary so the user knows what happened.
+			cancelMsg := "⏹️ *Task cancelled.*"
+			if infoVal, ok := chatRunInfos.LoadAndDelete(chatID); ok {
+				info := infoVal.(loop.IterationInfo)
+				cancelMsg += "\n\n" + formatStopSummary(info)
+			}
+			cancelMsg += "\n\n_Session state saved. Send a new message to continue._"
+			sendAsync(bot, chatID, cancelMsg,
+				&telegram.SendOpts{ParseMode: telegram.ParseModeMarkdownV2, ReplyToMessageID: messageID})
 			return
 		}
 

cmd/odek/wsapprover.go

@@ -37,6 +37,7 @@ type wsApprover struct {
 	pending    map[string]chan string        // request ID → response channel
 	mu         sync.Mutex
 	approveAll map[danger.RiskClass]bool     // trust-cached risk classes
+	cancel     chan struct{}                 // closed by Cancel() to interrupt waiting PromptCommand
 }
 
 // newWSApprover creates a wsApprover that sends requests via sendFn.
@@ -45,6 +46,7 @@ func newWSApprover(sendFn func(v any) error) *wsApprover {
 		sendFn:     sendFn,
 		pending:    make(map[string]chan string),
 		approveAll: make(map[danger.RiskClass]bool),
+		cancel:     make(chan struct{}),
 	}
 }
 
@@ -79,9 +81,15 @@ func (a *wsApprover) PromptCommand(cls danger.RiskClass, cmd, description string
 		return fmt.Errorf("approval: send failed: %w", err)
 	}
 
-	// Wait for response (60s timeout prevents agent deadlock)
+	// Wait for response, cancellation, or timeout (60s).
 	select {
 	case action := <-resp:
+		// Ack the user's choice back to the browser for UI feedback.
+		a.sendFn(map[string]any{
+			"type":   "approval_ack",
+			"id":     id,
+			"action": action,
+		})
 		switch action {
 		case "approve":
 			return nil
@@ -91,6 +99,8 @@ func (a *wsApprover) PromptCommand(cls danger.RiskClass, cmd, description string
 		default:
 			return fmt.Errorf("operation denied by user: %s", cmd)
 		}
+	case <-a.cancel:
+		return fmt.Errorf("approval cancelled: %s", cmd)
 	case <-time.After(60 * time.Second):
 		return fmt.Errorf("approval timeout: %s", cmd)
 	}
@@ -118,3 +128,14 @@ func (a *wsApprover) newID() string {
 	rand.Read(b)
 	return "apr-" + hex.EncodeToString(b)
 }
+
+// Cancel interrupts any pending PromptCommand by closing the cancel channel.
+// Safe to call multiple times — subsequent calls are no-ops.
+func (a *wsApprover) Cancel() {
+	select {
+	case <-a.cancel:
+		// Already closed.
+	default:
+		close(a.cancel)
+	}
+}

cmd/odek/wsapprover_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/BackendStack21/kode/internal/danger"
 )
@@ -267,3 +268,47 @@ func TestWSApprover_PromptOperation_SendError(t *testing.T) {
 		t.Fatal("expected error for send failure in operation")
 	}
 }
+
+// ── Test Cancel ────────────────────────────────────────────────────────
+
+func TestWSApprover_Cancel_InterruptsPrompt(t *testing.T) {
+	var acked bool
+	sendFn := func(v any) error {
+		if m, ok := v.(map[string]any); ok && m["type"] == "approval_ack" {
+			acked = true
+		}
+		return nil
+	}
+	a := newWSApprover(sendFn)
+
+	done := make(chan error, 1)
+	go func() {
+		done <- a.PromptCommand(danger.Safe, "test", "")
+	}()
+
+	// Cancel immediately.
+	a.Cancel()
+
+	select {
+	case err := <-done:
+		if err == nil {
+			t.Error("expected error from cancelled PromptCommand")
+		}
+		if !strings.Contains(err.Error(), "cancelled") {
+			t.Errorf("expected 'cancelled' in error, got: %v", err)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("PromptCommand did not return after Cancel() within 3s")
+	}
+
+	// Ack event should NOT be sent on cancel — the user didn't respond.
+	if acked {
+		t.Error("approval_ack should not be sent on cancel")
+	}
+}
+
+func TestWSApprover_Cancel_Idempotent(t *testing.T) {
+	a := newWSApprover(func(v any) error { return nil })
+	a.Cancel()
+	a.Cancel() // second call should not panic
+}

internal/telegram/approver.go

@@ -45,6 +45,7 @@ type TelegramApprover struct {
 	mu      sync.Mutex
 	trusted map[danger.RiskClass]bool
 	log     Logger
+	cancel  chan struct{} // closed by Cancel() to interrupt waiting PromptCommand
 
 	// ChatID is the Telegram chat where approval prompts are sent.
 	ChatID int64
@@ -58,6 +59,7 @@ func NewTelegramApprover(bot *Bot, chatID int64) *TelegramApprover {
 		pending: make(map[string]chan string),
 		trusted: make(map[danger.RiskClass]bool),
 		log:     NewNopLogger(),
+		cancel:  make(chan struct{}),
 	}
 }
 
@@ -70,6 +72,17 @@ func (a *TelegramApprover) SetLogger(l Logger) {
 	a.log = l
 }
 
+// Cancel interrupts any pending PromptCommand by closing the cancel channel.
+// Safe to call multiple times — subsequent calls are no-ops.
+func (a *TelegramApprover) Cancel() {
+	select {
+	case <-a.cancel:
+		// Already closed.
+	default:
+		close(a.cancel)
+	}
+}
+
 // PromptCommand sends an approval request with inline keyboard and waits
 // for the user to respond. Returns nil on approve/trust, error on deny/timeout.
 func (a *TelegramApprover) PromptCommand(cls danger.RiskClass, cmd, description string) error {
@@ -135,7 +148,7 @@ func (a *TelegramApprover) PromptCommand(cls danger.RiskClass, cmd, description
 		a.mu.Unlock()
 	}()
 
-	// Wait for response or timeout.
+	// Wait for response, cancellation, or timeout.
 	select {
 	case action := <-resp:
 		switch action {
@@ -157,6 +170,8 @@ func (a *TelegramApprover) PromptCommand(cls danger.RiskClass, cmd, description
 		default:
 			return fmt.Errorf("operation denied: %s", cmd)
 		}
+	case <-a.cancel:
+		return fmt.Errorf("approval cancelled: %s", cmd)
 	case <-time.After(approvalTimeout):
 		return fmt.Errorf("approval timeout: %s", cmd)
 	}

internal/telegram/approver_test.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
+	"time"
 
 	"github.com/BackendStack21/kode/internal/danger"
 )
@@ -306,3 +308,46 @@ func TestApprover_ConcurrentAccess(t *testing.T) {
 		t.Error("IsTrusted should be true after concurrent sets")
 	}
 }
+
+// ── Test Cancel ────────────────────────────────────────────────────────
+
+func TestTelegramApprover_Cancel_InterruptsPrompt(t *testing.T) {
+	// Cancel() should cause a blocked PromptCommand to return immediately
+	// with a cancellation error, not hang for the full timeout.
+	ts := testServer(t, nil)
+	defer ts.Close()
+	bot := testBot(t, ts)
+
+	a := NewTelegramApprover(bot, 1)
+
+	done := make(chan error, 1)
+	go func() {
+		done <- a.PromptCommand(danger.SystemWrite, "rm -rf /tmp/test", "test cancel")
+	}()
+
+	// Cancel immediately.
+	a.Cancel()
+
+	select {
+	case err := <-done:
+		if err == nil {
+			t.Error("expected error from cancelled PromptCommand, got nil")
+		}
+		if !strings.Contains(err.Error(), "cancelled") {
+			t.Errorf("expected 'cancelled' in error, got: %v", err)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("PromptCommand did not return after Cancel() within 3s")
+	}
+}
+
+func TestTelegramApprover_Cancel_Idempotent(t *testing.T) {
+	ts := testServer(t, nil)
+	defer ts.Close()
+	bot := testBot(t, ts)
+
+	a := NewTelegramApprover(bot, 1)
+	a.Cancel()
+	a.Cancel() // second call should not panic
+	// If we get here without panic, it's idempotent.
+}

internal/telegram/handler.go

@@ -331,8 +331,9 @@ func (h *Handler) handleCallback(cq *CallbackQuery) {
 
 	// Route approval callbacks to the per-chat TelegramApprover.
 	if a := h.GetApprover(cq.Message.Chat.ID); a != nil && a.HandleCallback(cq.Data) {
-		// Answer the callback (remove loading state on button).
-		if err := h.Bot.AnswerCallbackQuery(cq.ID, "", false); err != nil {
+		// Show a toast acknowledging the user's choice.
+		ack := approvalToast(cq.Data)
+		if err := h.Bot.AnswerCallbackQuery(cq.ID, ack, false); err != nil {
 			h.log.Error("answer callback query (approval) failed", "chat_id", cq.Message.Chat.ID, "error", err)
 			if h.OnError != nil {
 				h.OnError(cq.Message.Chat.ID, err)
@@ -577,3 +578,18 @@ func extractCommand(text string) (cmd string, args string) {
 	return cmdPart, args
 }
 
+
+// approvalToast returns a toast message for an approval callback action.
+// Parses the callback data prefix to determine the user's choice.
+func approvalToast(data string) string {
+	switch {
+	case strings.HasPrefix(data, cbPrefixApprove):
+		return "✅ Approved"
+	case strings.HasPrefix(data, cbPrefixDeny):
+		return "❌ Denied"
+	case strings.HasPrefix(data, cbPrefixTrust):
+		return "🔒 Trusted for this session"
+	default:
+		return ""
+	}
+}