@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/core/AiProfiles.test.js

@@ -10,6 +10,28 @@ function createProjectRoot(prefix = 'taskforce-ai-profiles-') {
     return root;
 }
 const createdRoots = [];
+function enableAiProfileSeatLimit(core, workspaceId, userId, limit) {
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+    core.ensureBootstrapUserAccess({
+        userId,
+        workspaceId,
+        role: 'owner',
+        email: `${userId}@example.com`
+    });
+    core.updatePlanVersionFeatures({
+        planVersionId: 'free-v1',
+        features: [
+            { featureKey: 'collaboration.ai_profiles', access: 'limited', config: { maxAiProfiles: limit } }
+        ]
+    });
+    core.updateAccountEntitlement({
+        accountId: userId,
+        planVersionId: 'free-v1',
+        entitlementState: 'active',
+        actorUserId: 'system-admin',
+        actorRole: 'system_admin'
+    });
+}
 afterEach(() => {
     while (createdRoots.length > 0) {
         const root = createdRoots.pop();
@@ -76,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);
@@ -103,6 +247,125 @@ describe('TaskforceCore ai profiles', () => {
         expect(second.profile.surfaceType).toBe('coding_tool');
         expect(second.profile.color).toBe('#0ea5e9');
     });
+    it('applies default metadata for named agent profiles when optional fields are omitted', () => {
+        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: 'John Drake',
+            surfaceType: 'agent'
+        });
+        expect(resolved.profile.description).toBe('John Drake AI collaborator registered in Taskforce.');
+        expect(resolved.profile.role).toBe('AI Collaborator');
+        expect(resolved.profile.provider).toBeNull();
+        expect(resolved.profile.model).toBeNull();
+        expect(resolved.profile.surfaceType).toBe('agent');
+    });
+    it('self-heals sparse named agent profiles on re-resolve', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'John Drake'
+        });
+        expect(first.profile.description).toBeNull();
+        expect(first.profile.role).toBeNull();
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'John Drake',
+            surfaceType: 'agent',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(second.profile.description).toBe('John Drake AI collaborator registered in Taskforce.');
+        expect(second.profile.role).toBe('AI Collaborator');
+        expect(second.profile.provider).toBeNull();
+        expect(second.profile.model).toBeNull();
+        expect(second.profile.surfaceType).toBe('agent');
+    });
+    it('durably repairs sparse named agent profiles when listing profiles', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'John Drake'
+        });
+        expect(first.profile.description).toBeNull();
+        expect(first.profile.role).toBeNull();
+        core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'John Drake',
+            surfaceType: 'agent',
+            profileToken: first.profile.profileToken
+        });
+        core.db.prepare(`
+            UPDATE ai_profiles
+            SET description = NULL, role = NULL, provider = NULL, model = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).run('default', 'workspace-1', first.profile.id);
+        const listed = core.listAiProfiles('workspace-1')[0];
+        expect(listed.description).toBe('John Drake AI collaborator registered in Taskforce.');
+        expect(listed.role).toBe('AI Collaborator');
+        expect(listed.provider).toBeNull();
+        expect(listed.model).toBeNull();
+        const repaired = core.db.prepare(`
+            SELECT description, role, provider, model
+            FROM ai_profiles
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            LIMIT 1
+        `).get('default', 'workspace-1', first.profile.id);
+        expect(repaired).toEqual({
+            description: 'John Drake AI collaborator registered in Taskforce.',
+            role: 'AI Collaborator',
+            provider: null,
+            model: null
+        });
+    });
+    it('durably repairs sparse coding-tool profiles when resolving by token lookup', () => {
+        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'
+        });
+        core.db.prepare(`
+            UPDATE ai_profiles
+            SET description = NULL, role = NULL, provider = NULL, model = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).run('default', 'workspace-1', resolved.profile.id);
+        const fetched = core.getAiProfileByToken({
+            workspaceId: 'workspace-1',
+            profileToken: resolved.profile.profileToken
+        });
+        expect(fetched).toEqual(expect.objectContaining({
+            description: 'Codex coding agent connected through MCP.',
+            role: 'Coding Agent',
+            provider: 'OpenAI',
+            model: 'Codex',
+            surfaceType: 'coding_tool'
+        }));
+        const repaired = core.db.prepare(`
+            SELECT description, role, provider, model
+            FROM ai_profiles
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            LIMIT 1
+        `).get('default', 'workspace-1', resolved.profile.id);
+        expect(repaired).toEqual({
+            description: 'Codex coding agent connected through MCP.',
+            role: 'Coding Agent',
+            provider: 'OpenAI',
+            model: 'Codex'
+        });
+    });
     it('ignores empty-string optional ai profile updates instead of clearing stored values', () => {
         const projectRoot = createProjectRoot();
         createdRoots.push(projectRoot);
@@ -368,6 +631,216 @@ describe('TaskforceCore ai profiles', () => {
         expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
         expect(core.listAiProfiles('workspace-2')).toHaveLength(1);
     });
+    it('allows token-based re-resolve even when the ai profile limit is full', () => {
+        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 first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex Prime',
+            icon: 'Sparkles',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.created).toBe(false);
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(second.profile.name).toBe('Codex Prime');
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
+    it('reuses an exact-match ai profile even when the ai profile limit is full', () => {
+        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 first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Automation Codex' }, { trustedSeatScope: 'cloud_metered' });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Automation Codex',
+            role: 'Assistant',
+        }, { trustedSeatScope: 'cloud_metered' });
+        expect(second.created).toBe(false);
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(second.profile.role).toBe('Assistant');
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
+    it('blocks net-new ai profile creation when the ai profile limit is full', () => {
+        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 first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' }, { trustedSeatScope: 'cloud_metered' });
+        expect(first.created).toBe(true);
+        try {
+            core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' }, { trustedSeatScope: 'cloud_metered' });
+            throw new Error('Expected AI profile creation 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');
+            expect(error.statusCode).toBe(403);
+            expect(error.details).toEqual({
+                workspaceId: 'workspace-1',
+                limit: 1,
+                used: 1,
+                remaining: 0
+            });
+        }
+    });
+    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);
@@ -393,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);
@@ -458,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);