feat: quiet Slack notifications with in-place message updates (#30)

* feat: quiet Slack notifications with in-place message updates

Redesign notifications to reduce channel noise:

1. The original "started working on" message is updated in-place on
   state changes (retrying, switching engine, completed, failed) via
   Slack's chat.update API. No new messages in the main channel.

2. Completion details (summary, MR link, cost) go in the thread only —
   reply_broadcast is now false, so the main channel stays clean.

3. Retries and engine fallbacks reuse the existing notification thread
   and inject SLACK_THREAD_TS, instead of calling runNotifyStart again
   and posting duplicate "started working on" messages.

4. Terminal failures update the original message with ❌ status.

Notifications.Channel interface bumped to v3 with new UpdateMessage
method. Discord and Telegram implementations are no-op.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: update knownInterfaceVersions for notifications v3

The plugin host still expected version 1 for notification plugins,
which would reject external plugins declaring interface_version=3.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mattcamp

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- **Quieter Slack notifications**: the original "started working on" message is
+  now updated in-place with status changes (retrying, completed, failed) instead
+  of posting new messages. Completion details go in the thread only — no more
+  broadcast to the main channel. Retries and fallbacks reuse the existing thread
+  instead of posting duplicate start messages. Notifications interface bumped to
+  version 3 with new `UpdateMessage` method (`chat.update` for Slack).
+
 ### Fixed
 
 - **Review poller acting on bot summary comments**: the classifier now only

internal/controller/controller.go

@@ -1037,6 +1037,7 @@ func (r *Reconciler) handleJobComplete(ctx context.Context, tr *taskrun.TaskRun)
 	}
 
 	if hasTicket {
+		// Post detailed completion to the thread (no broadcast).
 		for _, n := range r.notifiers {
 			if err := n.NotifyComplete(ctx, cachedTicket, result, tr.NotificationThreadRef); err != nil {
 				r.logger.ErrorContext(ctx, "completion notification failed",
@@ -1045,6 +1046,18 @@ func (r *Reconciler) handleJobComplete(ctx context.Context, tr *taskrun.TaskRun)
 				)
 			}
 		}
+		// Update the original message in the main channel with final status.
+		statusEmoji := "\u2705"
+		statusText := "completed"
+		if !result.Success {
+			statusEmoji = "\u274C"
+			statusText = "failed"
+		}
+		statusLine := fmt.Sprintf("%s *Osmia %s:* %s", statusEmoji, statusText, cachedTicket.Title)
+		if result.MergeRequestURL != "" {
+			statusLine += fmt.Sprintf(" — <%s|View MR>", result.MergeRequestURL)
+		}
+		r.updateNotificationStatus(ctx, tr.NotificationThreadRef, statusLine)
 	}
 
 	// Extract knowledge from the completed task into episodic memory.
@@ -1512,6 +1525,10 @@ func (r *Reconciler) handleJobFailed(ctx context.Context, tr *taskrun.TaskRun, r
 		}
 	}
 
+	// Update the original notification message with failure status.
+	r.updateNotificationStatus(ctx, tr.NotificationThreadRef,
+		fmt.Sprintf("\u274C *Osmia failed:* %s", tr.TicketID))
+
 	// Extract knowledge from the failed task into episodic memory.
 	if r.memoryExtractor != nil {
 		go r.extractMemory(ctx, tr)
@@ -1558,6 +1575,11 @@ func (r *Reconciler) launchFallbackJob(ctx context.Context, tr *taskrun.TaskRun,
 
 	engineCfg := r.baseEngineConfig(engineName)
 
+	// Reuse the existing notification thread and update the original message.
+	injectThreadRef(&engineCfg, tr.NotificationThreadRef)
+	r.updateNotificationStatus(ctx, tr.NotificationThreadRef,
+		fmt.Sprintf("\U0001F504 *Switching engine:* %s", engineName))
+
 	if err := r.prepareSession(ctx, tr.ID); err != nil {
 		r.logger.ErrorContext(ctx, "failed to prepare session storage for fallback job",
 			"task_run_id", tr.ID,
@@ -1892,6 +1914,17 @@ func (r *Reconciler) resolvePreMergeApproval(ctx context.Context, tr *taskrun.Ta
 				)
 			}
 		}
+		statusEmoji := "\u2705"
+		statusText := "completed"
+		if !result.Success {
+			statusEmoji = "\u274C"
+			statusText = "failed"
+		}
+		statusLine := fmt.Sprintf("%s *Osmia %s:* %s", statusEmoji, statusText, cachedTicket.Title)
+		if result.MergeRequestURL != "" {
+			statusLine += fmt.Sprintf(" — <%s|View MR>", result.MergeRequestURL)
+		}
+		r.updateNotificationStatus(ctx, tr.NotificationThreadRef, statusLine)
 	}
 
 	if r.memoryExtractor != nil {
@@ -2532,6 +2565,23 @@ func (r *Reconciler) runNotifyStart(ctx context.Context, ticket ticketing.Ticket
 	return threadRef
 }
 
+// updateNotificationStatus updates the original notification message in-place
+// with a brief status line. This keeps the main channel clean — only the
+// original message changes, no new messages are posted.
+func (r *Reconciler) updateNotificationStatus(ctx context.Context, threadRef string, status string) {
+	if threadRef == "" {
+		return
+	}
+	for _, n := range r.notifiers {
+		if err := n.UpdateMessage(ctx, threadRef, status); err != nil {
+			r.logger.WarnContext(ctx, "failed to update notification status",
+				"channel", n.Name(),
+				"error", err,
+			)
+		}
+	}
+}
+
 // injectThreadRef adds SLACK_THREAD_TS to the engine config's Env map so that
 // agent pods can post threaded Slack messages via the MCP server.
 func injectThreadRef(cfg *engine.EngineConfig, threadRef string) {
@@ -2699,6 +2749,11 @@ func (r *Reconciler) launchRetryJob(ctx context.Context, tr *taskrun.TaskRun, pr
 
 	engineCfg := r.baseEngineConfig(tr.CurrentEngine)
 
+	// Reuse the existing notification thread and update the original message.
+	injectThreadRef(&engineCfg, tr.NotificationThreadRef)
+	r.updateNotificationStatus(ctx, tr.NotificationThreadRef,
+		fmt.Sprintf("\U0001F504 *Retrying:* %s", task.Title))
+
 	if err := r.prepareSession(ctx, tr.ID); err != nil {
 		r.logger.ErrorContext(ctx, "failed to prepare session storage for retry job",
 			"task_run_id", tr.ID,
@@ -3702,6 +3757,17 @@ func (r *Reconciler) handleJudgeComplete(ctx context.Context, tr *taskrun.TaskRu
 				)
 			}
 		}
+		statusEmoji := "\u2705"
+		statusText := "completed"
+		if !result.Success {
+			statusEmoji = "\u274C"
+			statusText = "failed"
+		}
+		statusLine := fmt.Sprintf("%s *Osmia %s:* %s", statusEmoji, statusText, cachedTicket.Title)
+		if result.MergeRequestURL != "" {
+			statusLine += fmt.Sprintf(" — <%s|View MR>", result.MergeRequestURL)
+		}
+		r.updateNotificationStatus(ctx, tournamentThreadRef, statusLine)
 	}
 
 	// Extract memory from the winning candidate's task run.

pkg/plugin/host.go

@@ -94,7 +94,7 @@ func NewHost(healthCfg HealthConfig, logger *slog.Logger) *Host {
 // are refused at load time.
 var knownInterfaceVersions = map[PluginType]int{
 	PluginTypeTicketing:     1,
-	PluginTypeNotifications: 1,
+	PluginTypeNotifications: 3,
 	PluginTypeApproval:      1,
 	PluginTypeSecrets:       1,
 	PluginTypeReview:        1,

pkg/plugin/notifications/discord/discord.go

@@ -145,6 +145,11 @@ func (d *DiscordChannel) NotifyComplete(ctx context.Context, ticket ticketing.Ti
 	return d.sendEmbed(ctx, embed)
 }
 
+// UpdateMessage is a no-op — Discord webhook messages cannot be updated.
+func (d *DiscordChannel) UpdateMessage(_ context.Context, _ string, _ string) error {
+	return nil
+}
+
 // Name returns the unique identifier for this notification channel.
 func (d *DiscordChannel) Name() string {
 	return channelName

pkg/plugin/notifications/notifications.go

@@ -12,7 +12,7 @@ import (
 )
 
 // InterfaceVersion is the current version of the NotificationChannel interface.
-const InterfaceVersion = 2
+const InterfaceVersion = 3
 
 // Channel is the interface that notification backends must implement.
 // All methods are fire-and-forget — errors are logged but do not block
@@ -36,6 +36,11 @@ type Channel interface {
 	// reply (and, where supported, broadcast to the channel) in the identified thread.
 	NotifyComplete(ctx context.Context, ticket ticketing.Ticket, result engine.TaskResult, threadRef string) error
 
+	// UpdateMessage replaces the content of a previously posted message
+	// identified by messageRef (e.g. a Slack message timestamp). Backends
+	// that do not support updates should return nil (no-op).
+	UpdateMessage(ctx context.Context, messageRef string, text string) error
+
 	// Name returns the unique identifier for this channel (e.g. "slack", "teams").
 	Name() string
 

pkg/plugin/notifications/slack/slack.go

@@ -199,13 +199,29 @@ func (s *SlackChannel) NotifyComplete(ctx context.Context, ticket ticketing.Tick
 		})
 	}
 
-	// Broadcast to the channel when posting as a thread reply so that the
-	// completion message is visible to anyone not following the thread.
-	replyBroadcast := threadRef != ""
-	_, err := s.postMessage(ctx, summary, blocks, threadRef, replyBroadcast)
+	// Post completion details in the thread only — the controller updates the
+	// original message in the main channel separately via UpdateMessage.
+	_, err := s.postMessage(ctx, summary, blocks, threadRef, false)
 	return err
 }
 
+// UpdateMessage replaces the content of a previously posted message.
+// messageRef must be the Slack message timestamp returned by NotifyStart.
+func (s *SlackChannel) UpdateMessage(ctx context.Context, messageRef string, text string) error {
+	if messageRef == "" {
+		return nil
+	}
+
+	blocks := []slackBlock{
+		{
+			Type: "section",
+			Text: &slackText{Type: "mrkdwn", Text: text},
+		},
+	}
+
+	return s.updateMessage(ctx, messageRef, text, blocks)
+}
+
 // Name returns the unique identifier for this notification channel.
 func (s *SlackChannel) Name() string {
 	return channelName
@@ -274,3 +290,66 @@ func (s *SlackChannel) postMessage(ctx context.Context, fallbackText string, blo
 
 	return slackResp.TS, nil
 }
+
+// slackUpdateMessage is the payload sent to chat.update.
+type slackUpdateMessage struct {
+	Channel string       `json:"channel"`
+	TS      string       `json:"ts"`
+	Text    string       `json:"text"`
+	Blocks  []slackBlock `json:"blocks"`
+}
+
+// updateMessage replaces the content of a previously posted message via
+// chat.update. Requires the same chat:write scope as chat.postMessage.
+func (s *SlackChannel) updateMessage(ctx context.Context, ts string, fallbackText string, blocks []slackBlock) error {
+	msg := slackUpdateMessage{
+		Channel: s.channelID,
+		TS:      ts,
+		Text:    fallbackText,
+		Blocks:  blocks,
+	}
+
+	body, err := json.Marshal(msg)
+	if err != nil {
+		return fmt.Errorf("marshalling slack update: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.apiURL+"/chat.update", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("creating slack update request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	req.Header.Set("Authorization", "Bearer "+s.token)
+
+	resp, err := s.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("sending slack update: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("reading slack update response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("slack API returned status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var slackResp slackResponse
+	if err := json.Unmarshal(respBody, &slackResp); err != nil {
+		return fmt.Errorf("unmarshalling slack update response: %w", err)
+	}
+
+	if !slackResp.OK {
+		return fmt.Errorf("slack API error: %s", slackResp.Error)
+	}
+
+	s.logger.DebugContext(ctx, "slack message updated",
+		slog.String("channel", s.channelID),
+		slog.String("ts", ts),
+	)
+
+	return nil
+}

pkg/plugin/notifications/slack/slack_test.go

@@ -225,15 +225,15 @@ func TestSlackChannel_NotifyComplete(t *testing.T) {
 			wantSummaryText: "Fixed the login flow",
 		},
 		{
-			name:      "successful completion threaded with broadcast",
+			name:      "successful completion threaded without broadcast",
 			ticket:    sampleTicket(),
 			threadRef: "1234567890.000001",
 			result: engine.TaskResult{
 				Success: true,
 				Summary: "Applied dependency upgrade",
 			},
 			wantSuccess:        true,
-			wantReplyBroadcast: true,
+			wantReplyBroadcast: false,
 		},
 		{
 			name:   "failed completion",

pkg/plugin/notifications/telegram/telegram.go

@@ -132,6 +132,12 @@ func (t *TelegramChannel) NotifyComplete(ctx context.Context, ticket ticketing.T
 	return t.sendMessage(ctx, text)
 }
 
+// UpdateMessage is a no-op — Telegram bot messages would require storing
+// message IDs which is not currently supported.
+func (t *TelegramChannel) UpdateMessage(_ context.Context, _ string, _ string) error {
+	return nil
+}
+
 // Name returns the unique identifier for this notification channel.
 func (t *TelegramChannel) Name() string {
 	return channelName