@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/core/AiProfileService.test.js

@@ -80,6 +80,11 @@ describe('AiProfileService', () => {
             color: '#0ea5e9',
             surfaceType: 'coding_tool',
             providerMetadata: { source: 'sync' },
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: '2026-03-22T10:00:00.000Z',
             createdAt: '2026-03-22T10:00:00.000Z',
             updatedAt: '2026-03-22T10:05:00.000Z',
             lastActiveAt: '2026-03-22T10:05:00.000Z'
@@ -131,6 +136,11 @@ describe('AiProfileService', () => {
                                 color: profile.color,
                                 surface_type: profile.surfaceType,
                                 provider_metadata_json: JSON.stringify(profile.providerMetadata),
+                                archived_at: profile.archivedAt,
+                                archived_by: profile.archivedBy,
+                                archived_reason: profile.archivedReason,
+                                merged_into_profile_id: profile.mergedIntoProfileId,
+                                roster_state_updated_at: profile.rosterStateUpdatedAt,
                                 created_at: profile.createdAt,
                                 updated_at: profile.updatedAt,
                                 last_active_at: profile.lastActiveAt
@@ -155,12 +165,20 @@ describe('AiProfileService', () => {
         const upsertSql = statements.find((statement) => statement.includes('INSERT INTO ai_profiles'));
         expect(upsertSql).toBeTruthy();
         expect(upsertSql).toContain('id, tenant_id, workspace_id, profile_token, name, username, icon, color,');
-        expect(upsertSql).toContain('surface_type, provider_metadata_json, created_at, updated_at, last_active_at');
+        expect(upsertSql).toContain('surface_type, seat_scope, provider_metadata_json,');
+        expect(upsertSql).toContain('archived_at, archived_by, archived_reason, merged_into_profile_id,');
+        expect(upsertSql).toContain('roster_state_updated_at, created_at, updated_at, last_active_at');
         expect(upsertSql).toContain('ON CONFLICT(id) DO UPDATE SET');
         expect(upsertSql).toContain('workspace_id = excluded.workspace_id');
         expect(upsertSql).toContain('profile_token = excluded.profile_token');
         expect(upsertSql).toContain('surface_type = excluded.surface_type');
+        expect(upsertSql).toContain('seat_scope = excluded.seat_scope');
         expect(upsertSql).toContain('provider_metadata_json = excluded.provider_metadata_json');
+        expect(upsertSql).toContain('archived_at = excluded.archived_at');
+        expect(upsertSql).toContain('archived_by = excluded.archived_by');
+        expect(upsertSql).toContain('archived_reason = excluded.archived_reason');
+        expect(upsertSql).toContain('merged_into_profile_id = excluded.merged_into_profile_id');
+        expect(upsertSql).toContain('roster_state_updated_at = excluded.roster_state_updated_at');
         expect(upsertSql).toContain('last_active_at = excluded.last_active_at');
     });
 });

package/dist/core/AiProfiles.test.js

@@ -98,6 +98,128 @@ describe('TaskforceCore ai profiles', () => {
         expect(second.profile.icon).toBe('Sparkles');
         expect(second.profile.color).toBe('#0ea5e9');
     });
+    it('updates ai profile avatar urls without changing the registered icon fallback', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#0ea5e9'
+        });
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Favatar.webp';
+        const avatarSourceUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Fsource.webp';
+        const updated = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl,
+            avatarSourceUrl
+        });
+        expect(updated.avatarUrl).toBe(avatarUrl);
+        expect(updated.avatarSourceUrl).toBe(avatarSourceUrl);
+        expect(updated.icon).toBe('Bot');
+        expect(core.listAiProfiles('workspace-1')[0]?.avatarUrl).toBe(avatarUrl);
+        expect(core.listAiProfiles('workspace-1')[0]?.avatarSourceUrl).toBe(avatarSourceUrl);
+        const cleared = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl: null,
+            avatarSourceUrl: null
+        });
+        expect(cleared.avatarUrl).toBeNull();
+        expect(cleared.avatarSourceUrl).toBeNull();
+    });
+    it('preserves synced ai profile avatars when metadata-only sync payloads omit avatar fields', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#0ea5e9'
+        });
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Favatar.webp';
+        const avatarSourceUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Fsource.webp';
+        const updated = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl,
+            avatarSourceUrl
+        });
+        const { avatarUrl: _avatarUrl, avatarSourceUrl: _avatarSourceUrl, ...metadataOnlyProfile } = updated;
+        const metadataUpdatedAt = new Date(Date.parse(updated.updatedAt) + 1000).toISOString();
+        const replayed = core.upsertAiProfileForSync({
+            ...metadataOnlyProfile,
+            name: 'Codex Metadata Refresh',
+            updatedAt: metadataUpdatedAt,
+            lastActiveAt: metadataUpdatedAt
+        });
+        expect(replayed.name).toBe('Codex Metadata Refresh');
+        expect(replayed.avatarUrl).toBe(avatarUrl);
+        expect(replayed.avatarSourceUrl).toBe(avatarSourceUrl);
+    });
+    it('clears synced ai profile avatars when sync payloads explicitly send null avatar fields', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#0ea5e9'
+        });
+        const updated = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Favatar.webp',
+            avatarSourceUrl: '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Fsource.webp'
+        });
+        const clearedAt = new Date(Date.parse(updated.updatedAt) + 1000).toISOString();
+        const cleared = core.upsertAiProfileForSync({
+            ...updated,
+            avatarUrl: null,
+            avatarSourceUrl: null,
+            updatedAt: clearedAt,
+            lastActiveAt: clearedAt
+        });
+        expect(cleared.avatarUrl).toBeNull();
+        expect(cleared.avatarSourceUrl).toBeNull();
+    });
+    it('repairs missing synced ai profile avatars when timestamps match', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#0ea5e9'
+        });
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Favatar.webp';
+        const avatarSourceUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Fsource.webp';
+        const updated = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl,
+            avatarSourceUrl
+        });
+        core.db.prepare(`
+            UPDATE ai_profiles
+            SET avatar_url = NULL,
+                avatar_source_url = NULL
+            WHERE id = ?
+        `).run(updated.id);
+        const repaired = core.upsertAiProfileForSync(updated);
+        expect(repaired.updatedAt).toBe(updated.updatedAt);
+        expect(repaired.avatarUrl).toBe(avatarUrl);
+        expect(repaired.avatarSourceUrl).toBe(avatarSourceUrl);
+    });
     it('stores expanded ai profile fields and preserves them when omitted on re-resolve', () => {
         const projectRoot = createProjectRoot();
         createdRoots.push(projectRoot);
@@ -533,12 +655,12 @@ describe('TaskforceCore ai profiles', () => {
         const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
         core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
         enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Automation Codex' });
+        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Automation Codex' }, { trustedSeatScope: 'cloud_metered' });
         const second = core.resolveAiProfile({
             workspaceId: 'workspace-1',
             name: 'Automation Codex',
-            role: 'Assistant'
-        });
+            role: 'Assistant',
+        }, { trustedSeatScope: 'cloud_metered' });
         expect(second.created).toBe(false);
         expect(second.profile.id).toBe(first.profile.id);
         expect(second.profile.role).toBe('Assistant');
@@ -550,10 +672,10 @@ describe('TaskforceCore ai profiles', () => {
         const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
         core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
         enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
+        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' }, { trustedSeatScope: 'cloud_metered' });
         expect(first.created).toBe(true);
         try {
-            core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' });
+            core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' }, { trustedSeatScope: 'cloud_metered' });
             throw new Error('Expected AI profile creation to be blocked');
         }
         catch (error) {
@@ -568,6 +690,157 @@ describe('TaskforceCore ai profiles', () => {
             });
         }
     });
+    it('counts only cloud-metered ai profiles toward the seat limit', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
+        const local = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Local Codex',
+        }, { trustedSeatScope: 'local_unmetered' });
+        const cloud = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Cloud Codex',
+        }, { trustedSeatScope: 'cloud_metered' });
+        const extraLocal = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Another Local Agent',
+        }, { trustedSeatScope: 'local_unmetered' });
+        expect(local.profile.seatScope).toBe('local_unmetered');
+        expect(cloud.profile.seatScope).toBe('cloud_metered');
+        expect(extraLocal.profile.seatScope).toBe('local_unmetered');
+        expect(core.countAiProfileUsage('workspace-1')).toEqual({
+            used: 1,
+            limit: 1,
+            remaining: 0
+        });
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(3);
+    });
+    it('honors configured ai profile limits even when legacy plan data stores the feature as enabled', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+        core.ensureBootstrapUserAccess({
+            userId: 'owner-u1',
+            workspaceId: 'workspace-1',
+            role: 'owner',
+            email: 'owner-u1@example.com'
+        });
+        core.updatePlanVersionFeatures({
+            planVersionId: 'free-v1',
+            features: [
+                { featureKey: 'collaboration.ai_profiles', access: 'enabled', config: { maxAiProfiles: 20 } }
+            ]
+        });
+        core.db.prepare(`
+            UPDATE plan_feature_matrix
+            SET access = 'enabled',
+                config_json = ?
+            WHERE tenant_id = ? AND plan_version_id = ? AND feature_key = ?
+        `).run(JSON.stringify({ maxAiProfiles: 20 }), 'default', 'free-v1', 'collaboration.ai_profiles');
+        core.updateAccountEntitlement({
+            accountId: 'owner-u1',
+            planVersionId: 'free-v1',
+            entitlementState: 'active',
+            actorUserId: 'system-admin',
+            actorRole: 'system_admin'
+        });
+        core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Cloud Codex',
+        }, { trustedSeatScope: 'cloud_metered' });
+        expect(core.countAiProfileUsage('workspace-1')).toEqual({
+            used: 1,
+            limit: 20,
+            remaining: 19
+        });
+    });
+    it('blocks cloud promotion when a local ai profile would exceed the seat limit', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
+        core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Cloud Bot',
+        }, { trustedSeatScope: 'cloud_metered' });
+        const local = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Hybrid Bot',
+        }, { trustedSeatScope: 'local_unmetered' });
+        try {
+            core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Hybrid Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
+            throw new Error('Expected cloud promotion to be blocked');
+        }
+        catch (error) {
+            expect(error.message).toContain('No AI seats are available for this workspace');
+            expect(error.code).toBe('AI_PROFILE_LIMIT_REACHED');
+        }
+        const refreshed = core.getAiProfileByToken({
+            workspaceId: 'workspace-1',
+            profileToken: local.profile.profileToken
+        });
+        expect(refreshed?.seatScope).toBe('local_unmetered');
+    });
+    it('keeps local and cloud MCP profiles separate when they share the same name', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const cloud = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex', surfaceType: 'coding_tool' }, { trustedSeatScope: 'cloud_metered' });
+        const local = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex', surfaceType: 'coding_tool' }, { trustedSeatScope: 'local_unmetered' });
+        expect(local.created).toBe(true);
+        expect(local.profile.id).not.toBe(cloud.profile.id);
+        expect(local.profile.seatScope).toBe('local_unmetered');
+        expect(cloud.profile.seatScope).toBe('cloud_metered');
+        expect(core.countAiProfileUsage('workspace-1')).toEqual({
+            used: 1,
+            limit: null,
+            remaining: null
+        });
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(2);
+    });
+    it('claims a legacy unscoped profile for the trusted runtime instead of creating a duplicate', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const legacy = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Legacy Codex' });
+        expect(legacy.profile.seatScope ?? null).toBeNull();
+        const claimed = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Legacy Codex', surfaceType: 'coding_tool' }, { trustedSeatScope: 'local_unmetered' });
+        expect(claimed.created).toBe(false);
+        expect(claimed.profile.id).toBe(legacy.profile.id);
+        expect(claimed.profile.seatScope).toBe('local_unmetered');
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
+    it('reactivates a retired legacy unscoped profile for the trusted runtime instead of recreating it', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const legacy = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Retired Legacy Codex' });
+        expect(legacy.profile.seatScope ?? null).toBeNull();
+        core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: legacy.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const reactivated = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Retired Legacy Codex', surfaceType: 'coding_tool' }, { trustedSeatScope: 'cloud_metered' });
+        expect(reactivated.created).toBe(false);
+        expect(reactivated.profile.id).toBe(legacy.profile.id);
+        expect(reactivated.profile.archivedAt).toBeNull();
+        expect(reactivated.profile.seatScope).toBe('cloud_metered');
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
     it('merges two duplicate profiles, reassigning task assignees and comment authors', () => {
         const projectRoot = createProjectRoot();
         createdRoots.push(projectRoot);
@@ -593,16 +866,302 @@ describe('TaskforceCore ai profiles', () => {
             mergeId: second.profile.id
         });
         expect(merged.id).toBe(first.profile.id);
-        // Duplicate profile should be gone
+        // Duplicate profile should leave the active roster but remain archived for history and sync.
         const profiles = core.listAiProfiles('workspace-1');
         expect(profiles.some((p) => p.id === second.profile.id)).toBe(false);
         expect(profiles.some((p) => p.id === first.profile.id)).toBe(true);
+        const archivedProfiles = core.listAiProfiles('workspace-1', { includeArchived: true });
+        const archivedDuplicate = archivedProfiles.find((p) => p.id === second.profile.id);
+        expect(archivedDuplicate).toMatchObject({
+            id: second.profile.id,
+            archivedReason: 'merged_duplicate',
+            mergedIntoProfileId: first.profile.id,
+            archivedBy: first.profile.id
+        });
+        expect(archivedDuplicate?.archivedAt).toBeTruthy();
         // Task assignee should point to the kept profile
         const updatedTask = core.getTask(task.id, 'workspace-1');
         expect(updatedTask?.assignee).toBe(first.profile.id);
         // Comment author should point to the kept profile
         expect(updatedTask?.comments?.[0]?.author).toBe(first.profile.id);
     });
+    it('archives AI profiles out of the active roster while preserving history and freeing seats', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-1', 1);
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool'
+        });
+        const archived = core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: first.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        expect(archived.id).toBe(first.profile.id);
+        expect(archived.archivedReason).toBe('manual_archive');
+        expect(archived.archivedBy).toBe('owner-1');
+        expect(archived.archivedAt).toBeTruthy();
+        expect(core.listAiProfiles('workspace-1')).toEqual([]);
+        expect(core.listAssignableActors('workspace-1').some((actor) => actor.id === first.profile.id)).toBe(false);
+        const historicalActor = core.resolveWorkspaceActor('workspace-1', first.profile.id);
+        expect(historicalActor?.id).toBe(first.profile.id);
+        expect(historicalActor?.label).toBe('Codex');
+        expect(historicalActor?.meta).toEqual(expect.objectContaining({
+            archivedReason: 'manual_archive'
+        }));
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Claude',
+            surfaceType: 'coding_tool'
+        });
+        expect(second.created).toBe(true);
+        const archivedProfiles = core.listAiProfiles('workspace-1', { includeArchived: true });
+        expect(archivedProfiles.map((profile) => profile.name)).toEqual(['Claude', 'Codex']);
+        const archivedEntry = archivedProfiles.find((profile) => profile.id === first.profile.id);
+        expect(archivedEntry?.archivedReason).toBe('manual_archive');
+        expect(archivedEntry?.rosterStateUpdatedAt).toBe(archivedEntry?.archivedAt);
+    });
+    it('keeps an archived AI profile archived when sync replays an equal-watermark active copy', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex T-714 Verifier',
+            surfaceType: 'coding_tool'
+        });
+        const archived = core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const replayedActive = core.upsertAiProfileForSync({
+            ...archived,
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            updatedAt: archived.updatedAt
+        });
+        expect(replayedActive.archivedAt).toBeTruthy();
+        expect(core.listAiProfiles('workspace-1')).toEqual([]);
+        const stored = core.listAiProfiles('workspace-1', { includeArchived: true })
+            .find((profile) => profile.id === archived.id);
+        expect(stored?.archivedAt).toBe(archived.archivedAt);
+        expect(stored?.archivedReason).toBe('manual_archive');
+    });
+    it('accepts newer synced seat scope for the same AI profile id', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const contaminated = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool'
+        }, { trustedSeatScope: 'cloud_metered' });
+        const repairedAt = new Date(Date.parse(contaminated.profile.updatedAt) + 1000).toISOString();
+        const repaired = core.upsertAiProfileForSync({
+            ...contaminated.profile,
+            seatScope: 'local_unmetered',
+            updatedAt: repairedAt,
+            lastActiveAt: repairedAt
+        });
+        expect(repaired.id).toBe(contaminated.profile.id);
+        expect(repaired.seatScope).toBe('local_unmetered');
+        const staleReplay = core.upsertAiProfileForSync({
+            ...contaminated.profile,
+            seatScope: 'cloud_metered',
+            updatedAt: contaminated.profile.updatedAt
+        });
+        expect(staleReplay.seatScope).toBe('local_unmetered');
+    });
+    it('keeps an archived AI profile archived when sync replays a newer metadata update with an older lifecycle timestamp', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Antigravity/jCodeMunch',
+            surfaceType: 'coding_tool'
+        });
+        const archived = core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const replayedActive = core.upsertAiProfileForSync({
+            ...archived,
+            description: 'Cloud-side metadata changed after the archive write was missed.',
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: resolved.profile.rosterStateUpdatedAt,
+            updatedAt: '2099-03-22T10:30:00.000Z'
+        });
+        expect(replayedActive.archivedAt).toBeTruthy();
+        const stored = core.listAiProfiles('workspace-1', { includeArchived: true })
+            .find((profile) => profile.id === archived.id);
+        expect(stored?.archivedAt).toBe(archived.archivedAt);
+        expect(stored?.description).toBe('Cloud-side metadata changed after the archive write was missed.');
+    });
+    it('repairs stale archived roster lifecycle timestamps before applying active sync snapshots', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool'
+        });
+        const archived = core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        core.db.prepare(`
+            UPDATE ai_profiles
+            SET roster_state_updated_at = ?
+            WHERE tenant_id = ? AND id = ?
+        `).run(resolved.profile.createdAt, 'default', archived.id);
+        const replayedActive = core.upsertAiProfileForSync({
+            ...archived,
+            description: 'Cloud active snapshot with newer metadata but no lifecycle marker.',
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: null,
+            updatedAt: '2099-03-22T10:30:00.000Z'
+        });
+        expect(replayedActive.archivedAt).toBe(archived.archivedAt);
+        expect(replayedActive.rosterStateUpdatedAt).toBe(archived.archivedAt);
+        const stored = core.listAiProfiles('workspace-1', { includeArchived: true })
+            .find((profile) => profile.id === archived.id);
+        expect(stored?.archivedAt).toBe(archived.archivedAt);
+        expect(stored?.description).toBe('Cloud active snapshot with newer metadata but no lifecycle marker.');
+        expect(core.listAiProfiles('workspace-1')).toEqual([]);
+    });
+    it('allows sync to reactivate an archived AI profile when lifecycle timestamp is newer', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Claude Code',
+            surfaceType: 'coding_tool'
+        });
+        const archived = core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const reactivated = core.upsertAiProfileForSync({
+            ...archived,
+            archivedAt: null,
+            archivedBy: null,
+            archivedReason: null,
+            mergedIntoProfileId: null,
+            rosterStateUpdatedAt: '2099-03-22T10:45:00.000Z',
+            updatedAt: '2099-03-22T10:45:00.000Z'
+        });
+        expect(reactivated.archivedAt).toBeNull();
+        expect(core.listAiProfiles('workspace-1').map((profile) => profile.id)).toEqual([resolved.profile.id]);
+    });
+    it('reactivates an archived AI profile when resolveAiProfile is called explicitly', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const initial = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool',
+        }, { trustedSeatScope: 'cloud_metered' });
+        core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: initial.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const reactivatedByName = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool'
+        }, { trustedSeatScope: 'cloud_metered' });
+        expect(reactivatedByName.created).toBe(false);
+        expect(reactivatedByName.profile.id).toBe(initial.profile.id);
+        expect(reactivatedByName.profile.archivedAt).toBeNull();
+        expect(reactivatedByName.profile.archivedReason).toBeNull();
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+        core.archiveAiProfile({
+            workspaceId: 'workspace-1',
+            profileId: initial.profile.id,
+            archivedBy: 'owner-1',
+            reason: 'manual_archive'
+        });
+        const reactivatedByToken = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            profileToken: initial.profile.profileToken,
+            surfaceType: 'coding_tool'
+        }, { trustedSeatScope: 'cloud_metered' });
+        expect(reactivatedByToken.created).toBe(false);
+        expect(reactivatedByToken.profile.id).toBe(initial.profile.id);
+        expect(reactivatedByToken.profile.profileToken).toBe(initial.profile.profileToken);
+        expect(reactivatedByToken.profile.archivedAt).toBeNull();
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
+    it('rejects archiving an AI profile that still owns open tasks', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const profile = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Antigravity',
+            surfaceType: 'agent'
+        });
+        core.createTask({
+            title: 'Still assigned',
+            status: 'in-progress',
+            assignee: profile.profile.id
+        }, { workspaceId: 'workspace-1' });
+        try {
+            core.archiveAiProfile({
+                workspaceId: 'workspace-1',
+                profileId: profile.profile.id,
+                archivedBy: 'owner-1',
+                reason: 'manual_archive'
+            });
+            expect.unreachable('Expected archiveAiProfile to reject open-task ownership');
+        }
+        catch (error) {
+            expect(error.code).toBe('AI_PROFILE_HAS_OPEN_TASKS');
+            expect(error.statusCode).toBe(409);
+            expect(error.details).toEqual({
+                workspaceId: 'workspace-1',
+                profileId: profile.profile.id,
+                openTaskCount: 1
+            });
+        }
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+        expect(core.listAiProfiles('workspace-1', { includeArchived: true })[0]?.archivedAt).toBeNull();
+    });
     it('canonicalizes AI names to profile ids when creating tasks and comments', () => {
         const projectRoot = createProjectRoot();
         createdRoots.push(projectRoot);
@@ -658,7 +1217,7 @@ describe('TaskforceCore ai profiles', () => {
         const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
         const reloaded = reloadedCore.getTask(task.id, 'workspace-1');
         const profiles = reloadedCore.listAiProfiles('workspace-1');
-        expect(profiles.map((profile) => profile.name)).toEqual(['Claude', 'Antigravity']);
+        expect(profiles.map((profile) => profile.name)).toEqual(['Antigravity', 'Claude']);
         const survivingAntigravityId = profiles.find((profile) => profile.name === 'Antigravity')?.id;
         expect(reloaded?.createdBy).toBe(claude.profile.id);
         expect(reloaded?.assignee).toBe(survivingAntigravityId);