feat(workflows): implement support reply workflow with triage, drafting, and sending steps

- Added support_reply_deps.go to define dependencies and constants for the support reply workflow.
- Implemented support_reply_test.go to cover various scenarios including happy paths, approval requirements, and error handling.
- Created workflow.go to manage the workflow execution, including step results and context.
- Developed workflow_test.go to validate the workflow registration, execution, and approval processes.

Author: grasberg

cmd/sofia/internal/gateway/fix_github_wiring.go

@@ -0,0 +1,115 @@
+package gateway
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"github.com/grasberg/sofia/pkg/agent"
+	"github.com/grasberg/sofia/pkg/autonomy"
+	"github.com/grasberg/sofia/pkg/config"
+	"github.com/grasberg/sofia/pkg/logger"
+	"github.com/grasberg/sofia/pkg/memory"
+	"github.com/grasberg/sofia/pkg/workflows"
+)
+
+// startGitHubAutonomy builds the fix-github-issue workflow + poller and
+// runs the poller loop in a goroutine until ctx is cancelled. A no-op when
+// cfg.GitHubAutonomy.Enabled is false or Repos is empty — callers always
+// pass through so the "off by default" contract holds.
+func startGitHubAutonomy(
+	ctx context.Context,
+	cfg *config.Config,
+	agentLoop *agent.AgentLoop,
+	memDB *memory.MemoryDB,
+	workspacePath string,
+) {
+	raw := cfg.GitHubAutonomy
+	if !raw.Enabled {
+		return
+	}
+	ghCfg := config.DefaultGitHubAutonomy(raw)
+	if len(ghCfg.Repos) == 0 {
+		logger.WarnC("workflows", "github_autonomy enabled but no repos configured — poller not started")
+		return
+	}
+	if memDB == nil {
+		logger.ErrorC("workflows", "github_autonomy requires a memory DB; disabled")
+		return
+	}
+
+	workspaceRoot := ghCfg.WorkspaceRoot
+	if workspaceRoot == "" {
+		workspaceRoot = filepath.Join(workspacePath, "github-autonomy")
+	}
+
+	deps := workflows.FixGitHubIssueDeps{
+		Classifier:     workflows.NewHeuristicIssueClassifier(),
+		Cloner:         workflows.NewShellCloner(),
+		Tester:         workflows.NewShellTester(),
+		Fixer:          workflows.NewNoopFixer(),
+		Pusher:         workflows.NewShellPusher(),
+		PRCreator:      workflows.NewShellPRCreator(),
+		IssueCommenter: workflows.NewShellIssueCommenter(),
+		BranchPrefix:   ghCfg.BranchPrefix,
+		WorkspaceRoot:  workspaceRoot,
+		UseFork:        ghCfg.UseFork,
+		Locale:         locaeFromEmailCfg(cfg),
+	}
+
+	registry := workflows.NewRegistry()
+	if err := workflows.RegisterFixGitHubIssue(registry, deps); err != nil {
+		logger.ErrorCF("workflows", "fix-github-issue registration failed",
+			map[string]any{"error": err.Error()})
+		return
+	}
+
+	goalSink := workflows.NewGoalSinkAdapter(autonomy.NewGoalManager(memDB), memDB)
+	gate := workflows.NewApprovalGateAdapter(agentLoop.GetApprovalGate())
+	runner := workflows.NewRunner(registry, goalSink, gate)
+
+	lister := workflows.NewShellIssueLister()
+	store := workflows.NewSemanticGraphProcessedStore(memDB)
+
+	poller, err := workflows.NewGitHubPoller(workflows.GitHubPollerConfig{
+		Repos:         ghCfg.Repos,
+		Label:         ghCfg.Label,
+		MaxConcurrent: ghCfg.MaxConcurrent,
+		BranchPrefix:  ghCfg.BranchPrefix,
+		CloneRoot:     workspaceRoot,
+		UseFork:       ghCfg.UseFork,
+		Locale:        deps.Locale,
+	}, lister, store, runner)
+	if err != nil {
+		logger.ErrorCF("workflows", "github poller construction failed",
+			map[string]any{"error": err.Error()})
+		return
+	}
+
+	interval := time.Duration(ghCfg.PollMinutes) * time.Minute
+	go poller.Start(ctx, interval)
+
+	logger.InfoCF("workflows", "fix-github-issue poller started",
+		map[string]any{
+			"repos":         ghCfg.Repos,
+			"label":         ghCfg.Label,
+			"poll_minutes":  ghCfg.PollMinutes,
+			"max_concurrent": ghCfg.MaxConcurrent,
+			"use_fork":      ghCfg.UseFork,
+			"workspace":     workspaceRoot,
+		})
+
+	_ = fmt.Sprintf // reserved for future logging helpers
+}
+
+// locaeFromEmailCfg returns the user's preferred locale — derived from the
+// email channel config which already carries it. Defaults to "sv" when the
+// email channel isn't configured.
+func locaeFromEmailCfg(cfg *config.Config) string {
+	loc := cfg.Channels.Email.UserLocale
+	if loc == "" {
+		return "sv"
+	}
+	return loc
+}

cmd/sofia/internal/gateway/helpers.go

@@ -199,6 +199,22 @@ func gatewayCmd(debug bool) error {
 	memDB := agentLoop.GetMemoryDB()
 	if memDB != nil {
 		healthServer.RegisterCheck("database", health.DatabaseCheck(memDB))
+
+		// Wire persistent email dedupe into the email channel so polling is
+		// idempotent across restarts. Also wire the support-reply workflow
+		// when the email channel is configured as Autonomous=true.
+		if emailCh, ok := channelManager.GetChannel("email"); ok {
+			if ec, ok := emailCh.(*channels.EmailChannel); ok {
+				ec.SetIngestedStore(memDB)
+
+				if ec.Config().Autonomous {
+					if err := wireSupportReplyWorkflow(ec, agentLoop, memDB); err != nil {
+						logger.ErrorCF("workflows", "support-reply wiring failed",
+							map[string]any{"error": err.Error()})
+					}
+				}
+			}
+		}
 	}
 	dataDir := filepath.Dir(cfg.MemoryDBPath())
 	healthServer.RegisterCheck("disk_space", health.DiskSpaceCheck(dataDir, 0))
@@ -239,6 +255,8 @@ func gatewayCmd(debug bool) error {
 		fmt.Printf("✓ Web UI available at http://%s:%d\n", cfg.WebUI.Host, cfg.WebUI.Port)
 	}
 
+	startGitHubAutonomy(ctx, cfg, agentLoop, memDB, cfg.WorkspacePath())
+
 	go agentLoop.Run(ctx)
 
 	sigChan := make(chan os.Signal, 1)

cmd/sofia/internal/gateway/support_reply_wiring.go

@@ -0,0 +1,114 @@
+package gateway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/grasberg/sofia/pkg/agent"
+	"github.com/grasberg/sofia/pkg/autonomy"
+	"github.com/grasberg/sofia/pkg/channels"
+	"github.com/grasberg/sofia/pkg/logger"
+	"github.com/grasberg/sofia/pkg/memory"
+	"github.com/grasberg/sofia/pkg/workflows"
+)
+
+// wireSupportReplyWorkflow assembles the runtime graph for the
+// "support-reply" workflow and installs an OnInbound handler on the email
+// channel so autonomous polls trigger it. No-ops gracefully when any piece
+// is missing (e.g. sender not configured).
+func wireSupportReplyWorkflow(
+	ec *channels.EmailChannel,
+	agentLoop *agent.AgentLoop,
+	memDB *memory.MemoryDB,
+) error {
+	if ec == nil {
+		return fmt.Errorf("email channel is nil")
+	}
+	if memDB == nil {
+		return fmt.Errorf("memory DB is nil")
+	}
+
+	sender := ec.Sender()
+	if sender == nil {
+		return fmt.Errorf("email channel has no sender configured")
+	}
+
+	cfg := ec.Config()
+
+	goalSink := workflows.NewGoalSinkAdapter(autonomy.NewGoalManager(memDB), memDB)
+	gate := workflows.NewApprovalGateAdapter(agentLoop.GetApprovalGate())
+	kb := workflows.NewKBAdapter(memDB)
+
+	archiver := channels.NewGmailArchiver(channels.GmailArchiverOptions{
+		BinaryPath: cfg.GogBinary,
+		Account:    cfg.Username,
+		MarkRead:   cfg.MarkAsReadOnIngest,
+	})
+
+	var classifier agent.RiskClassifier
+	if ag := agentLoop.GetApprovalGate(); ag != nil {
+		// Reuse the gate's own classifier so workflow risk_check and
+		// ApprovalGate.RequiresApproval share one ruleset.
+		classifier = ag
+	}
+
+	deps := workflows.SupportReplyDeps{
+		KBSearcher:            kb,
+		KBUpserter:            kb,
+		Sender:                sender,
+		Archiver:              archiver,
+		Classifier:            classifier,
+		DefaultLocale:         cfg.UserLocale,
+		AutoSendPriorityFloor: workflows.PriorityP3,
+	}
+
+	registry := workflows.NewRegistry()
+	if err := workflows.RegisterSupportReply(registry, deps); err != nil {
+		return fmt.Errorf("register support-reply: %w", err)
+	}
+
+	runner := workflows.NewRunner(registry, goalSink, gate)
+
+	ec.SetInboundHandler(func(email channels.IncomingEmail) {
+		inputs := map[string]any{
+			workflows.InputFrom:      email.From,
+			workflows.InputSubject:   email.Subject,
+			workflows.InputBody:      email.Body,
+			workflows.InputMessageID: email.MessageID,
+			workflows.InputLocale:    cfg.UserLocale,
+			workflows.InputAgentID:   "support",
+		}
+		_, err := runner.Run(
+			context.Background(),
+			workflows.WorkflowSupportReply,
+			"support",
+			fmt.Sprintf("Reply to %s: %s", email.From, truncateSubject(email.Subject)),
+			inputs,
+		)
+		if err != nil {
+			logger.WarnCF("workflows", "support-reply run ended with error",
+				map[string]any{
+					"from":       email.From,
+					"message_id": email.MessageID,
+					"error":      err.Error(),
+				})
+		}
+	})
+
+	logger.InfoCF("workflows", "support-reply workflow wired",
+		map[string]any{
+			"account":    cfg.Username,
+			"locale":     cfg.UserLocale,
+			"mark_read":  cfg.MarkAsReadOnIngest,
+			"autonomous": cfg.Autonomous,
+		})
+	return nil
+}
+
+// truncateSubject clips long subjects so goal names stay readable.
+func truncateSubject(s string) string {
+	if len(s) <= 60 {
+		return s
+	}
+	return s[:60] + "…"
+}