package repos

import (
	"context"
	"fmt"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func TestPrimaryRepositoryRoleKeepsPersistedSpelling(t *testing.T) {
	require.Equal(t, "canonical", RepoRolePrimary)
}

type activityProjectorCheckpointFixture struct {
	WorkspaceID  string    `gorm:"size:64;not null;uniqueIndex:uk_resource_activity_projector_checkpoint"`
	ResourceType string    `gorm:"size:64;not null;uniqueIndex:uk_resource_activity_projector_checkpoint"`
	ResourceID   string    `gorm:"size:64;not null;uniqueIndex:uk_resource_activity_projector_checkpoint"`
	LastPolledAt time.Time `gorm:"not null;index"`
}

func (activityProjectorCheckpointFixture) TableName() string {
	return "resource_activity_projector_checkpoints"
}

func newTestStore(t *testing.T) *Store {
	t.Helper()
	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
	require.NoError(t, err)
	sqlDatabase, err := db.DB()
	require.NoError(t, err)
	t.Cleanup(func() {
		if err := sqlDatabase.Close(); err != nil {
			t.Errorf("close resource repository test database: %v", err)
		}
	})
	require.NoError(t, db.AutoMigrate(&ResourceRepository{}, &ResourceRepositoryAccessGrant{}, &ResourceRepositoryLifecycleEvent{}, &activityProjectorCheckpointFixture{}))
	return New(db)
}

func TestStoreListByAGSRepoID(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 30, 10, 0, 0, 0, time.UTC)
	for _, repo := range []ResourceRepository{
		{ID: "rr_1", WorkspaceID: "wsp_1", ResourceType: ResourceTypeMemory, ResourceID: "mem_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "usr_1", RepoName: "one.mem", RepoFullName: "usr_1/one.mem", AGSRepoID: "123", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
		{ID: "rr_2", WorkspaceID: "wsp_1", ResourceType: ResourceTypeKBSource, ResourceID: "src_1", RepoRole: RepoRoleMirror, OwnerKind: "workspace", RepoOwner: "wsp_1", RepoName: "two", RepoFullName: "wsp_1/two", AGSRepoID: "456", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
		{ID: "rr_3", WorkspaceID: "wsp_2", ResourceType: ResourceTypeSkillRepository, ResourceID: "sk_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "usr_2", RepoName: "three.sk", RepoFullName: "usr_2/three.sk", AGSRepoID: "123", CreatedBy: "usr_2", UpdatedBy: "usr_2", CreatedAt: now, UpdatedAt: now},
	} {
		_, err := store.Upsert(ctx, repo)
		require.NoError(t, err)
	}

	repos, err := store.ListByAGSRepoID(ctx, " 123 ")
	require.NoError(t, err)
	require.Len(t, repos, 2)
	require.Equal(t, []string{"rr_1", "rr_3"}, []string{repos[0].ID, repos[1].ID})

	empty, err := store.ListByAGSRepoID(ctx, "")
	require.NoError(t, err)
	require.Empty(t, empty)
}

func TestStoreUpsertRepositoryReportsCreated(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 30, 11, 0, 0, 0, time.UTC)
	repo := ResourceRepository{ID: "rr_1", WorkspaceID: "wsp_1", ResourceType: ResourceTypeMemory, ResourceID: "mem_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "usr_1", RepoName: "runbooks.mem", RepoFullName: "usr_1/runbooks.mem", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now}

	created, err := store.Upsert(ctx, repo)
	require.NoError(t, err)
	require.True(t, created.Created)
	require.Equal(t, repo.ID, created.Repository.ID)

	repo.RepoName = "runbooks-renamed.mem"
	repo.RepoFullName = "usr_1/runbooks-renamed.mem"
	repo.UpdatedAt = now.Add(time.Minute)
	updated, err := store.Upsert(ctx, repo)
	require.NoError(t, err)
	require.False(t, updated.Created)
	require.Equal(t, "usr_1/runbooks-renamed.mem", updated.Repository.RepoFullName)
}

func TestIsBoundToWorkspaceUsesBothRepositoryAndWorkspace(t *testing.T) {
	store := newTestStore(t)
	now := time.Date(2026, 8, 14, 0, 0, 0, 0, time.UTC)
	for _, repo := range []ResourceRepository{
		{ID: "rr_a", WorkspaceID: "wsp_a", ResourceType: ResourceTypeMemory, ResourceID: "mem_a", RepoRole: RepoRolePrimary, OwnerKind: "workspace", RepoOwner: "shared", RepoName: "docs", RepoFullName: "shared/docs", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
		{ID: "rr_b", WorkspaceID: "wsp_b", ResourceType: ResourceTypeMemory, ResourceID: "mem_b", RepoRole: RepoRolePrimary, OwnerKind: "workspace", RepoOwner: "other", RepoName: "docs", RepoFullName: "other/docs", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
	} {
		_, err := store.Upsert(context.Background(), repo)
		require.NoError(t, err)
	}

	bound, err := store.IsBoundToWorkspace(context.Background(), "wsp_a", "shared/docs")
	require.NoError(t, err)
	require.True(t, bound)
	bound, err = store.IsBoundToWorkspace(context.Background(), "wsp_b", "shared/docs")
	require.NoError(t, err)
	require.False(t, bound)
	bound, err = store.IsBoundToWorkspace(context.Background(), "wsp_a", "other/docs")
	require.NoError(t, err)
	require.False(t, bound)
}

func TestResolveUniqueAutomationRepositoryIsExactAndRejectsAmbiguity(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 8, 22, 3, 30, 0, 0, time.UTC)
	seed := func(id, workspaceID, resourceType, resourceID, repository string) {
		owner, name, ok := strings.Cut(repository, "/")
		require.True(t, ok)
		_, err := store.Upsert(ctx, ResourceRepository{
			ID: id, WorkspaceID: workspaceID, ResourceType: resourceType, ResourceID: resourceID,
			RepoRole: RepoRolePrimary, OwnerKind: "test", RepoOwner: owner, RepoName: name,
			RepoFullName: repository, CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now,
		})
		require.NoError(t, err)
	}
	seed("rr_skill", "wsp_other", ResourceTypeSkillRepository, "skill_1", "acme/native")
	seed("rr_native", "wsp_1", ResourceTypeAutomationRepository, AutomationRepositoryResourceID("acme/native"), "acme/native")
	require.True(t, store.db.Migrator().HasIndex(&ResourceRepository{}, "idx_resource_repositories_type_resource_role"))

	var plan []struct{ Detail string }
	require.NoError(t, store.db.Raw(
		"EXPLAIN QUERY PLAN SELECT workspace_id, repo_full_name FROM resource_repositories WHERE resource_type = ? AND resource_id = ? AND repo_role = ? LIMIT 2",
		ResourceTypeAutomationRepository,
		AutomationRepositoryResourceID("acme/native"),
		RepoRolePrimary,
	).Scan(&plan).Error)
	planText := ""
	for _, row := range plan {
		planText += row.Detail + "\n"
	}
	require.Contains(t, planText, "idx_resource_repositories_type_resource_role")
	require.NotContains(t, planText, "USE TEMP B-TREE")

	queries := 0
	callbackName := "test:resolve_unique_automation_workspace"
	require.NoError(t, store.db.Callback().Query().Before("gorm:query").Register(callbackName, func(*gorm.DB) {
		queries++
	}))
	t.Cleanup(func() { _ = store.db.Callback().Query().Remove(callbackName) })

	repository, found, err := store.ResolveUniqueAutomationRepository(ctx, "acme/native")
	require.NoError(t, err)
	require.True(t, found)
	require.Equal(t, "wsp_1", repository.WorkspaceID)
	require.Equal(t, "acme/native", repository.RepoFullName)
	require.Equal(t, 1, queries, "one repository-bound query with a two-row ambiguity limit")

	seed("rr_ambiguous", "wsp_2", ResourceTypeAutomationRepository, AutomationRepositoryResourceID("acme/native"), "acme/native")
	for index := 3; index <= 64; index++ {
		seed(
			fmt.Sprintf("rr_ambiguous_%d", index),
			fmt.Sprintf("wsp_%d", index),
			ResourceTypeAutomationRepository,
			AutomationRepositoryResourceID("acme/native"),
			"acme/native",
		)
	}
	queriesBeforeManyLookup := queries
	_, found, err = store.ResolveUniqueAutomationRepository(ctx, "acme/native")
	require.ErrorContains(t, err, "ambiguous")
	require.False(t, found)
	require.Equal(t, queriesBeforeManyLookup+1, queries, "many matching workspaces still use one query whose LIMIT stops after two rows")

	repository, found, err = store.ResolveUniqueAutomationRepository(ctx, "acme/legacy")
	require.NoError(t, err)
	require.False(t, found)
	require.Empty(t, repository.WorkspaceID)
}

func TestStoreUpsertsRepositoryAccessGrant(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	createdAt := time.Date(2026, 6, 18, 10, 0, 0, 0, time.UTC)
	reconciledAt := createdAt.Add(time.Minute)

	created, err := store.UpsertAccessGrant(ctx, ResourceRepositoryAccessGrant{
		WorkspaceID:   " wsp_1 ",
		ResourceType:  ResourceTypeKBSource,
		ResourceID:    "src_1",
		RepoRole:      RepoRolePrimary,
		RepoFullName:  "wsp_1/source.kb",
		AGSRepoID:     "repo_1",
		SubjectType:   "user",
		SubjectID:     "usr_1",
		Permission:    AccessPermissionRead,
		IntentType:    AccessIntentTypeKBGrant,
		IntentID:      "kbg_1",
		IntentProfile: AccessPermissionRead,
		CreatedBy:     "manager",
		UpdatedBy:     "manager",
		CreatedAt:     createdAt,
		UpdatedAt:     createdAt,
	})
	require.NoError(t, err)
	require.Equal(t, ResourceRepositoryAccessGrantID("wsp_1", ResourceTypeKBSource, "src_1", RepoRolePrimary, "user", "usr_1", AccessIntentTypeKBGrant, "kbg_1"), created.ID)
	require.Equal(t, AccessStatusPending, created.Status)
	require.False(t, created.Materialized)

	updated, err := store.UpsertAccessGrant(ctx, ResourceRepositoryAccessGrant{
		WorkspaceID:      "wsp_1",
		ResourceType:     ResourceTypeKBSource,
		ResourceID:       "src_1",
		RepoRole:         RepoRolePrimary,
		RepoFullName:     "wsp_1/source-renamed.kb",
		AGSRepoID:        "repo_2",
		SubjectType:      "user",
		SubjectID:        "usr_1",
		Permission:       AccessPermissionWrite,
		IntentType:       AccessIntentTypeKBGrant,
		IntentID:         "kbg_1",
		IntentProfile:    AccessPermissionWrite,
		Materialized:     true,
		Status:           AccessStatusCurrent,
		CreatedBy:        "manager",
		UpdatedBy:        "manager-2",
		ReconciledBy:     "manager-2",
		CreatedAt:        createdAt,
		UpdatedAt:        reconciledAt,
		LastReconciledAt: &reconciledAt,
	})
	require.NoError(t, err)
	require.Equal(t, created.ID, updated.ID)
	require.Equal(t, "repo_2", updated.AGSRepoID)
	require.Equal(t, AccessPermissionWrite, updated.Permission)
	require.True(t, updated.Materialized)
	require.Equal(t, AccessStatusCurrent, updated.Status)
	require.Equal(t, "manager-2", updated.ReconciledBy)
	require.NotNil(t, updated.LastReconciledAt)

	byIntent, err := store.ListAccessGrantsByIntentIDs(ctx, "wsp_1", AccessIntentTypeKBGrant, []string{"kbg_1", "kbg_1", ""})
	require.NoError(t, err)
	require.Len(t, byIntent, 1)
	require.Equal(t, updated.ID, byIntent[0].ID)

	forIntent, err := store.ListAccessGrantsForIntent(ctx, "wsp_1", AccessIntentTypeKBGrant, "kbg_1")
	require.NoError(t, err)
	require.Len(t, forIntent, 1)
	require.Equal(t, updated.ID, forIntent[0].ID)

	active, err := store.ListActiveAccessGrantsForRepositorySubject(ctx, "wsp_1", "wsp_1/source-renamed.kb", "user", "usr_1")
	require.NoError(t, err)
	require.Len(t, active, 1)
	require.Equal(t, updated.ID, active[0].ID)
}

func TestStoreListsOnlyActiveRepositoryAccessGrantsForSubject(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 18, 11, 0, 0, 0, time.UTC)
	for _, grant := range []ResourceRepositoryAccessGrant{
		{
			WorkspaceID:   "wsp_1",
			ResourceType:  ResourceTypeKBSource,
			ResourceID:    "src_1",
			RepoRole:      RepoRolePrimary,
			RepoFullName:  "wsp_1/source.kb",
			SubjectType:   "user",
			SubjectID:     "usr_1",
			Permission:    AccessPermissionRead,
			IntentType:    AccessIntentTypeKBGrant,
			IntentID:      "kbg_active",
			IntentProfile: AccessPermissionRead,
			Status:        AccessStatusCurrent,
			CreatedBy:     "manager",
			UpdatedBy:     "manager",
			CreatedAt:     now,
			UpdatedAt:     now,
		},
		{
			WorkspaceID:   "wsp_1",
			ResourceType:  ResourceTypeKBSource,
			ResourceID:    "src_1",
			RepoRole:      RepoRolePrimary,
			RepoFullName:  "wsp_1/source.kb",
			SubjectType:   "user",
			SubjectID:     "usr_1",
			Permission:    AccessPermissionRead,
			IntentType:    AccessIntentTypeKBGrant,
			IntentID:      "kbg_revoked",
			IntentProfile: AccessPermissionRead,
			Status:        AccessStatusRevoked,
			CreatedBy:     "manager",
			UpdatedBy:     "manager",
			CreatedAt:     now,
			UpdatedAt:     now,
		},
		{
			WorkspaceID:   "wsp_2",
			ResourceType:  ResourceTypeKBSource,
			ResourceID:    "src_1",
			RepoRole:      RepoRolePrimary,
			RepoFullName:  "wsp_1/source.kb",
			SubjectType:   "user",
			SubjectID:     "usr_1",
			Permission:    AccessPermissionRead,
			IntentType:    AccessIntentTypeKBGrant,
			IntentID:      "kbg_other_workspace",
			IntentProfile: AccessPermissionRead,
			Status:        AccessStatusCurrent,
			CreatedBy:     "manager",
			UpdatedBy:     "manager",
			CreatedAt:     now,
			UpdatedAt:     now,
		},
	} {
		_, err := store.UpsertAccessGrant(ctx, grant)
		require.NoError(t, err)
	}

	active, err := store.ListActiveAccessGrantsForRepositorySubject(ctx, "wsp_1", "wsp_1/source.kb", "user", "usr_1")
	require.NoError(t, err)
	require.Len(t, active, 1)
	require.Equal(t, "kbg_active", active[0].IntentID)

	empty, err := store.ListAccessGrantsByIntentIDs(ctx, "wsp_1", AccessIntentTypeKBGrant, nil)
	require.NoError(t, err)
	require.Empty(t, empty)
}

func TestStoreRejectsRepositoryAccessGrantWithoutIdentity(t *testing.T) {
	store := newTestStore(t)

	_, err := store.UpsertAccessGrant(context.Background(), ResourceRepositoryAccessGrant{WorkspaceID: "wsp_1"})
	require.ErrorContains(t, err, "resource repository access grant identity is required")
}

func TestStoreDeletesRepositoryMappingsAndAccessGrantsForResource(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 18, 12, 0, 0, 0, time.UTC)
	_, err := store.Upsert(ctx, ResourceRepository{
		ID:           "rr_1",
		WorkspaceID:  "wsp_1",
		ResourceType: ResourceTypeMemory,
		ResourceID:   "mem_1",
		RepoRole:     RepoRolePrimary,
		OwnerKind:    "personal",
		RepoOwner:    "usr_1",
		RepoName:     "runbooks.mem",
		RepoFullName: "usr_1/runbooks.mem",
		CreatedBy:    "usr_1",
		UpdatedBy:    "usr_1",
		CreatedAt:    now,
		UpdatedAt:    now,
	})
	require.NoError(t, err)
	_, err = store.UpsertAccessGrant(ctx, ResourceRepositoryAccessGrant{
		WorkspaceID:   "wsp_1",
		ResourceType:  ResourceTypeMemory,
		ResourceID:    "mem_1",
		RepoRole:      RepoRolePrimary,
		RepoFullName:  "usr_1/runbooks.mem",
		SubjectType:   "agent",
		SubjectID:     "agt_1",
		Permission:    AccessPermissionRead,
		IntentType:    AccessIntentTypeKBGrant,
		IntentID:      "bind_1",
		IntentProfile: AccessPermissionRead,
		Status:        AccessStatusCurrent,
		CreatedBy:     "usr_1",
		UpdatedBy:     "usr_1",
		CreatedAt:     now,
		UpdatedAt:     now,
	})
	require.NoError(t, err)

	deleted, err := store.DeleteForResource(ctx, "wsp_1", ResourceTypeMemory, "mem_1")
	require.NoError(t, err)
	require.Len(t, deleted, 1)
	require.Equal(t, "rr_1", deleted[0].ID)

	repos, err := store.ListForResource(ctx, "wsp_1", ResourceTypeMemory, "mem_1")
	require.NoError(t, err)
	require.Empty(t, repos)
	grants, err := store.ListAccessGrantsForIntent(ctx, "wsp_1", AccessIntentTypeKBGrant, "bind_1")
	require.NoError(t, err)
	require.Empty(t, grants)
}

func TestStoreRecordsRepositoryLifecycleEvents(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 18, 13, 0, 0, 0, time.UTC)

	event, err := store.CreateLifecycleEvent(ctx, ResourceRepositoryLifecycleEvent{
		ID:           "rrle_1",
		WorkspaceID:  " wsp_1 ",
		ResourceType: ResourceTypeKBSource,
		ResourceID:   " src_1 ",
		RepoRole:     RepoRoleInsights,
		RepoOwner:    " usr_1 ",
		RepoName:     " source.kb ",
		Operation:    ResourceRepositoryLifecycleOperationDelete,
		Status:       ResourceRepositoryLifecycleStatusPending,
		CreatedBy:    " owner ",
		UpdatedBy:    " owner ",
		CreatedAt:    now,
		UpdatedAt:    now,
	})
	require.NoError(t, err)
	require.Equal(t, "wsp_1", event.WorkspaceID)
	require.Equal(t, "usr_1/source.kb", event.RepoFullName)

	later := now.Add(time.Minute)
	require.NoError(t, store.UpdateLifecycleEventStatus(ctx, event.ID, ResourceRepositoryLifecycleStatusFailed, "delete failed", "worker", later))

	events, err := store.ListLifecycleEventsForResource(ctx, "wsp_1", ResourceTypeKBSource, "src_1")
	require.NoError(t, err)
	require.Len(t, events, 1)
	require.Equal(t, ResourceRepositoryLifecycleStatusFailed, events[0].Status)
	require.Equal(t, "delete failed", events[0].LastError)
	require.Equal(t, "worker", events[0].UpdatedBy)
	require.Equal(t, later, events[0].UpdatedAt)
}

func TestListActivityProjectorRepositoriesReturnsConfiguredMemorySkillAndKBRepos(t *testing.T) {
	ctx := context.Background()
	store := newTestStore(t)
	now := time.Date(2026, 6, 18, 14, 0, 0, 0, time.UTC)
	repos := []ResourceRepository{
		{ID: "rr_memory", WorkspaceID: "ws_1", ResourceType: ResourceTypeMemory, ResourceID: "mem_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "owner", RepoName: "m.mem", RepoFullName: "owner/m.mem", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
		{ID: "rr_skill", WorkspaceID: "ws_1", ResourceType: ResourceTypeSkillRepository, ResourceID: "skill_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "owner", RepoName: "s.sk", RepoFullName: "owner/s.sk", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now.Add(time.Minute)},
		{ID: "rr_memory_mirror", WorkspaceID: "ws_1", ResourceType: ResourceTypeMemory, ResourceID: "mem_1", RepoRole: RepoRoleMirror, OwnerKind: "personal", RepoOwner: "owner", RepoName: "m-mirror.mem", RepoFullName: "owner/m-mirror.mem", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now},
		{ID: "rr_kb", WorkspaceID: "ws_1", ResourceType: ResourceTypeKBSource, ResourceID: "src_1", RepoRole: RepoRolePrimary, OwnerKind: "personal", RepoOwner: "owner", RepoName: "kb", RepoFullName: "owner/kb", CreatedBy: "usr_1", UpdatedBy: "usr_1", CreatedAt: now, UpdatedAt: now.Add(2 * time.Minute)},
	}
	for _, repo := range repos {
		_, err := store.Upsert(ctx, repo)
		require.NoError(t, err)
	}

	listed, err := store.ListActivityProjectorRepositories(ctx, ListActivityProjectorRepositoriesOptions{
		Limit: 10,
		Selectors: []ActivityProjectorRepositorySelector{
			{ResourceType: ResourceTypeMemory, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeSkillRepository, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeKBSource, RepoRoles: []string{RepoRolePrimary, RepoRoleMirror, RepoRoleInsights}},
		},
	})
	require.NoError(t, err)
	require.Equal(t, []string{"rr_memory", "rr_skill", "rr_kb"}, []string{listed[0].ID, listed[1].ID, listed[2].ID})

	limited, err := store.ListActivityProjectorRepositories(ctx, ListActivityProjectorRepositoriesOptions{
		Limit: 1,
		Selectors: []ActivityProjectorRepositorySelector{
			{ResourceType: ResourceTypeMemory, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeSkillRepository, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeKBSource, RepoRoles: []string{RepoRolePrimary, RepoRoleMirror, RepoRoleInsights}},
		},
	})
	require.NoError(t, err)
	require.Len(t, limited, 1)
	require.Equal(t, "rr_memory", limited[0].ID)

	err = store.db.WithContext(ctx).Create(&activityProjectorCheckpointFixture{
		WorkspaceID:  "ws_1",
		ResourceType: ResourceTypeMemory,
		ResourceID:   "mem_1",
		LastPolledAt: now.Add(2 * time.Minute),
	}).Error
	require.NoError(t, err)
	afterCheckpoint, err := store.ListActivityProjectorRepositories(ctx, ListActivityProjectorRepositoriesOptions{
		Limit: 1,
		Selectors: []ActivityProjectorRepositorySelector{
			{ResourceType: ResourceTypeMemory, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeSkillRepository, RepoRoles: []string{RepoRolePrimary}},
			{ResourceType: ResourceTypeKBSource, RepoRoles: []string{RepoRolePrimary, RepoRoleMirror, RepoRoleInsights}},
		},
	})
	require.NoError(t, err)
	require.Len(t, afterCheckpoint, 1)
	require.Equal(t, "rr_skill", afterCheckpoint[0].ID)
}