feat(tracker): route intake observer per project's provider

Replace the observer's single ports.Tracker with a TrackerResolver
interface so each project's poll is dispatched to the adapter that
matches its configured provider. SingleTrackerResolver lets tests and
single-provider deployments keep using one adapter without constructing
a map.

trackerRepo() now computes the per-provider scope:
- github: configured Repo, falling back to the parsed origin URL
- linear: configured Team key
- jira: configured ProjectKey + BaseURL (passed via TrackerRepo.BaseURL)

The daemon wires a multiTrackerResolver that owns three lazy adapters,
constructed only on first use so projects that don't configure a given
provider pay no auth or network cost. GitHub keeps the existing
AO_GITHUB_TOKEN + `gh auth token` precedence; Linear reads
AO_LINEAR_TOKEN; Jira reads AO_JIRA_EMAIL + AO_JIRA_TOKEN.

The `seen` map no longer indexes by bare native ID. With three
providers in play, native IDs collide (Linear "ENG-1" vs Jira "ENG-1"),
so dedupe runs only on the canonical "<provider>:<native>" form.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: anirudh5harma

backend/internal/daemon/tracker_intake_wiring.go

@@ -3,12 +3,15 @@ package daemon
 import (
 	"context"
 	"errors"
+	"fmt"
 	"log/slog"
 	"strings"
 	"sync"
 	"time"
 
 	trackergithub "github.com/aoagents/agent-orchestrator/backend/internal/adapters/tracker/github"
+	trackerjira "github.com/aoagents/agent-orchestrator/backend/internal/adapters/tracker/jira"
+	trackerlinear "github.com/aoagents/agent-orchestrator/backend/internal/adapters/tracker/linear"
 	"github.com/aoagents/agent-orchestrator/backend/internal/domain"
 	trackerintake "github.com/aoagents/agent-orchestrator/backend/internal/observe/trackerintake"
 	"github.com/aoagents/agent-orchestrator/backend/internal/ports"
@@ -17,14 +20,56 @@ import (
 	"github.com/aoagents/agent-orchestrator/backend/internal/storage/sqlite"
 )
 
-// startTrackerIntake wires the opt-in issue-intake loop. The tracker itself is
-// lazy so daemon startup and projects without intake enabled do not pay an auth
-// or network cost.
+// startTrackerIntake wires the opt-in issue-intake loop. Each provider's
+// adapter is constructed lazily on first use so daemon startup and projects
+// that don't use a given provider do not pay an auth or network cost.
 func startTrackerIntake(ctx context.Context, store *sqlite.Store, sessions *sessionsvc.Service, logger *slog.Logger) <-chan struct{} {
-	observer := trackerintake.New(newLazyGitHubTracker(logger), store, sessions, trackerintake.Config{Logger: logger})
+	resolver := newMultiTrackerResolver(logger)
+	observer := trackerintake.New(resolver, store, sessions, trackerintake.Config{Logger: logger})
 	return observer.Start(ctx)
 }
 
+// multiTrackerResolver routes per project's configured provider to a lazy
+// adapter. It implements trackerintake.TrackerResolver.
+type multiTrackerResolver struct {
+	logger *slog.Logger
+
+	githubOnce sync.Once
+	github     *lazyGitHubTracker
+
+	linearOnce sync.Once
+	linear     *lazyLinearTracker
+
+	jiraOnce sync.Once
+	jira     *lazyJiraTracker
+}
+
+func newMultiTrackerResolver(logger *slog.Logger) *multiTrackerResolver {
+	return &multiTrackerResolver{logger: logger}
+}
+
+// Tracker returns the lazy adapter for the configured provider, constructing
+// it on first request.
+func (r *multiTrackerResolver) Tracker(provider domain.TrackerProvider) (ports.Tracker, error) {
+	switch provider {
+	case "", domain.TrackerProviderGitHub:
+		r.githubOnce.Do(func() { r.github = newLazyGitHubTracker(r.logger) })
+		return r.github, nil
+	case domain.TrackerProviderLinear:
+		r.linearOnce.Do(func() { r.linear = newLazyLinearTracker(r.logger) })
+		return r.linear, nil
+	case domain.TrackerProviderJira:
+		r.jiraOnce.Do(func() { r.jira = newLazyJiraTracker(r.logger) })
+		return r.jira, nil
+	default:
+		return nil, fmt.Errorf("tracker intake: unknown provider %q", provider)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// GitHub lazy adapter (token sourced from env or gh CLI fallback)
+// ---------------------------------------------------------------------------
+
 type lazyGitHubTracker struct {
 	logger  *slog.Logger
 	tokens  *trackerTokenSource
@@ -118,3 +163,118 @@ func (s *trackerTokenSource) Token(ctx context.Context) (string, error) {
 	s.expiresAt = now.Add(trackerTokenCacheTTL)
 	return token, nil
 }
+
+// ---------------------------------------------------------------------------
+// Linear lazy adapter (env-only token)
+// ---------------------------------------------------------------------------
+
+type lazyLinearTracker struct {
+	logger  *slog.Logger
+	mu      sync.Mutex
+	tracker ports.Tracker
+}
+
+func newLazyLinearTracker(logger *slog.Logger) *lazyLinearTracker {
+	return &lazyLinearTracker{logger: logger}
+}
+
+func (t *lazyLinearTracker) Get(ctx context.Context, id domain.TrackerID) (domain.Issue, error) {
+	tracker, err := t.resolve()
+	if err != nil {
+		return domain.Issue{}, err
+	}
+	return tracker.Get(ctx, id)
+}
+
+func (t *lazyLinearTracker) List(ctx context.Context, repo domain.TrackerRepo, filter domain.ListFilter) ([]domain.Issue, error) {
+	tracker, err := t.resolve()
+	if err != nil {
+		return nil, err
+	}
+	return tracker.List(ctx, repo, filter)
+}
+
+func (t *lazyLinearTracker) Preflight(ctx context.Context) error {
+	tracker, err := t.resolve()
+	if err != nil {
+		return err
+	}
+	return tracker.Preflight(ctx)
+}
+
+func (t *lazyLinearTracker) resolve() (ports.Tracker, error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.tracker != nil {
+		return t.tracker, nil
+	}
+	tokens := trackerlinear.EnvTokenSource{EnvVars: []string{"AO_LINEAR_TOKEN"}}
+	tracker, err := trackerlinear.New(trackerlinear.Options{Token: tokens})
+	if err != nil {
+		if errors.Is(err, trackerlinear.ErrNoToken) {
+			t.logger.Warn("tracker intake disabled: no usable Linear token", "err", err)
+		}
+		return nil, err
+	}
+	t.tracker = tracker
+	return tracker, nil
+}
+
+// ---------------------------------------------------------------------------
+// Jira lazy adapter (env-only email + token)
+// ---------------------------------------------------------------------------
+
+type lazyJiraTracker struct {
+	logger  *slog.Logger
+	mu      sync.Mutex
+	tracker ports.Tracker
+}
+
+func newLazyJiraTracker(logger *slog.Logger) *lazyJiraTracker {
+	return &lazyJiraTracker{logger: logger}
+}
+
+func (t *lazyJiraTracker) Get(ctx context.Context, id domain.TrackerID) (domain.Issue, error) {
+	tracker, err := t.resolve()
+	if err != nil {
+		return domain.Issue{}, err
+	}
+	return tracker.Get(ctx, id)
+}
+
+func (t *lazyJiraTracker) List(ctx context.Context, repo domain.TrackerRepo, filter domain.ListFilter) ([]domain.Issue, error) {
+	tracker, err := t.resolve()
+	if err != nil {
+		return nil, err
+	}
+	return tracker.List(ctx, repo, filter)
+}
+
+func (t *lazyJiraTracker) Preflight(ctx context.Context) error {
+	tracker, err := t.resolve()
+	if err != nil {
+		return err
+	}
+	return tracker.Preflight(ctx)
+}
+
+func (t *lazyJiraTracker) resolve() (ports.Tracker, error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	if t.tracker != nil {
+		return t.tracker, nil
+	}
+	creds := trackerjira.EnvCredentials{
+		EmailVars: []string{"AO_JIRA_EMAIL"},
+		TokenVars: []string{"AO_JIRA_TOKEN"},
+	}
+	tracker, err := trackerjira.New(trackerjira.Options{Credentials: creds})
+	if err != nil {
+		if errors.Is(err, trackerjira.ErrNoCredentials) {
+			t.logger.Warn("tracker intake disabled: no usable Jira credentials", "err", err)
+		}
+		return nil, err
+	}
+	t.tracker = tracker
+	return tracker, nil
+}

backend/internal/observe/trackerintake/observer.go

@@ -42,6 +42,33 @@ type Spawner interface {
 	Spawn(ctx context.Context, cfg ports.SpawnConfig) (domain.Session, error)
 }
 
+// TrackerResolver picks the right tracker adapter for a project's configured
+// provider. The daemon wires a concrete resolver that holds a lazy adapter per
+// provider; tests use SingleTrackerResolver.
+type TrackerResolver interface {
+	Tracker(provider domain.TrackerProvider) (ports.Tracker, error)
+}
+
+// SingleTrackerResolver returns the same tracker for one specific provider and
+// refuses every other provider. It exists so tests (and single-provider
+// deployments) don't need to construct a map.
+type SingleTrackerResolver struct {
+	Provider domain.TrackerProvider
+	Adapter  ports.Tracker
+}
+
+// Tracker returns the wrapped adapter when the requested provider matches, or
+// when the resolver was constructed without a provider pin.
+func (s SingleTrackerResolver) Tracker(provider domain.TrackerProvider) (ports.Tracker, error) {
+	if s.Adapter == nil {
+		return nil, fmt.Errorf("tracker intake: no adapter for provider %q", provider)
+	}
+	if s.Provider == "" || provider == "" || provider == s.Provider {
+		return s.Adapter, nil
+	}
+	return nil, fmt.Errorf("tracker intake: no adapter for provider %q", provider)
+}
+
 // Config holds optional observer knobs. Zero values use production defaults.
 type Config struct {
 	Tick           time.Duration
@@ -52,7 +79,7 @@ type Config struct {
 
 // Observer polls configured projects and starts sessions for eligible issues.
 type Observer struct {
-	tracker        ports.Tracker
+	resolver       TrackerResolver
 	store          Store
 	spawner        Spawner
 	tick           time.Duration
@@ -63,8 +90,8 @@ type Observer struct {
 }
 
 // New constructs an Observer with safe defaults.
-func New(tracker ports.Tracker, store Store, spawner Spawner, cfg Config) *Observer {
-	o := &Observer{tracker: tracker, store: store, spawner: spawner, tick: cfg.Tick, failureBackoff: cfg.FailureBackoff, clock: cfg.Clock, logger: cfg.Logger, backoffUntil: map[string]time.Time{}}
+func New(resolver TrackerResolver, store Store, spawner Spawner, cfg Config) *Observer {
+	o := &Observer{resolver: resolver, store: store, spawner: spawner, tick: cfg.Tick, failureBackoff: cfg.FailureBackoff, clock: cfg.Clock, logger: cfg.Logger, backoffUntil: map[string]time.Time{}}
 	if o.tick <= 0 {
 		o.tick = DefaultTickInterval
 	}
@@ -94,7 +121,7 @@ func (o *Observer) Poll(ctx context.Context) error {
 	if err := ctx.Err(); err != nil {
 		return err
 	}
-	if o.tracker == nil || o.store == nil || o.spawner == nil {
+	if o.resolver == nil || o.store == nil || o.spawner == nil {
 		return nil
 	}
 	now := o.clock().UTC()
@@ -146,10 +173,15 @@ func (o *Observer) pollProject(ctx context.Context, project domain.ProjectRecord
 	}
 	repo, ok := trackerRepo(project, cfg)
 	if !ok {
-		o.logger.Warn("tracker intake: skipping project without tracker repo", "project", project.ID, "origin", project.RepoOriginURL)
+		o.logger.Warn("tracker intake: skipping project without tracker scope", "project", project.ID, "provider", cfg.Provider, "origin", project.RepoOriginURL)
 		return true
 	}
-	issues, err := o.tracker.List(ctx, repo, domain.ListFilter{
+	tracker, err := o.resolver.Tracker(cfg.Provider)
+	if err != nil {
+		o.logger.Warn("tracker intake: no adapter for provider", "project", project.ID, "provider", cfg.Provider, "err", err)
+		return true
+	}
+	issues, err := tracker.List(ctx, repo, domain.ListFilter{
 		State:    domain.ListOpen,
 		Labels:   cfg.Labels,
 		Assignee: cfg.Assignee,
@@ -171,7 +203,7 @@ func (o *Observer) pollProject(ctx context.Context, project domain.ProjectRecord
 			continue
 		}
 		issueID := CanonicalIssueID(issue.ID)
-		if issueID == "" || seen[issueID] || seen[domain.IssueID(issue.ID.Native)] {
+		if issueID == "" || seen[issueID] {
 			continue
 		}
 		if _, err := o.spawner.Spawn(ctx, ports.SpawnConfig{
@@ -185,9 +217,6 @@ func (o *Observer) pollProject(ctx context.Context, project domain.ProjectRecord
 			continue
 		}
 		seen[issueID] = true
-		if issue.ID.Native != "" {
-			seen[domain.IssueID(issue.ID.Native)] = true
-		}
 	}
 	return spawnFailed
 }
@@ -303,14 +332,32 @@ func trackerRepo(project domain.ProjectRecord, cfg domain.TrackerIntakeConfig) (
 	if provider == "" {
 		provider = domain.TrackerProviderGitHub
 	}
-	native := strings.TrimSpace(cfg.Repo)
-	if native == "" {
-		native = parseGitHubRepoNative(project.RepoOriginURL)
-	}
-	if provider != domain.TrackerProviderGitHub || native == "" {
+	switch provider {
+	case domain.TrackerProviderGitHub:
+		native := strings.TrimSpace(cfg.Repo)
+		if native == "" {
+			native = parseGitHubRepoNative(project.RepoOriginURL)
+		}
+		if native == "" {
+			return domain.TrackerRepo{}, false
+		}
+		return domain.TrackerRepo{Provider: provider, Native: native}, true
+	case domain.TrackerProviderLinear:
+		team := strings.TrimSpace(cfg.Team)
+		if team == "" {
+			return domain.TrackerRepo{}, false
+		}
+		return domain.TrackerRepo{Provider: provider, Native: team}, true
+	case domain.TrackerProviderJira:
+		projectKey := strings.TrimSpace(cfg.ProjectKey)
+		base := strings.TrimSpace(cfg.BaseURL)
+		if projectKey == "" || base == "" {
+			return domain.TrackerRepo{}, false
+		}
+		return domain.TrackerRepo{Provider: provider, Native: projectKey, BaseURL: base}, true
+	default:
 		return domain.TrackerRepo{}, false
 	}
-	return domain.TrackerRepo{Provider: provider, Native: native}, true
 }
 
 func parseGitHubRepoNative(remote string) string {