@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/core/AiProfiles.test.js

@@ -1,1873 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import Database from 'better-sqlite3';
-import { afterEach, describe, expect, it } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-function createProjectRoot(prefix = 'taskforce-ai-profiles-') {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'ai-profiles-test' }), 'utf-8');
-    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();
-        if (root && fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe('TaskforceCore ai profiles', () => {
-    it('creates workspace-scoped ai profiles and resolves them into task actor surfaces', () => {
-        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: '#ef6c00'
-        });
-        expect(resolved.created).toBe(true);
-        const actors = core.listAssignableActors('workspace-1');
-        expect(actors.some((actor) => actor.id === resolved.profile.id && actor.label === 'Codex' && actor.kind === 'ai')).toBe(true);
-        const task = core.createTask({
-            title: 'Assigned to named AI',
-            assignee: resolved.profile.id,
-            createdBy: resolved.profile.id,
-            comments: [
-                {
-                    id: 'comment-1',
-                    author: resolved.profile.id,
-                    text: 'Hello from Codex',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }
-            ]
-        }, { workspaceId: 'workspace-1' });
-        const fetched = core.getTask(task.id, 'workspace-1');
-        expect(fetched?.assignee).toBe(resolved.profile.id);
-        expect(fetched?.assigneeActor?.label).toBe('Codex');
-        expect(fetched?.createdByActor?.label).toBe('Codex');
-        expect(fetched?.comments?.[0]?.actor?.label).toBe('Codex');
-        expect(fetched?.assigneeActor?.meta).not.toHaveProperty('profileToken');
-        expect(fetched?.createdByActor?.meta).not.toHaveProperty('profileToken');
-        expect(fetched?.comments?.[0]?.actor?.meta).not.toHaveProperty('profileToken');
-    });
-    it('updates existing ai profile presentation fields when profileToken is presented again', () => {
-        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: 'Claude',
-            color: '#f59e0b'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude 2',
-            icon: 'Sparkles',
-            color: '#0ea5e9',
-            profileToken: first.profile.profileToken
-        });
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(second.profile.name).toBe('Claude 2');
-        expect(second.profile.username).toBe('claude-2');
-        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.avatarRevision).toBe(1);
-        expect(updated.avatarUpdatedAt).toBe(updated.updatedAt);
-        expect(updated.icon).toBe('Bot');
-        expect(core.listAiProfiles('workspace-1')[0]?.avatarUrl).toBe(avatarUrl);
-        expect(core.listAiProfiles('workspace-1')[0]?.avatarSourceUrl).toBe(avatarSourceUrl);
-        expect(core.listAiProfiles('workspace-1')[0]?.avatarRevision).toBe(1);
-        expect(core.listAiProfiles('workspace-1')[0]?.avatarUpdatedAt).toBe(updated.updatedAt);
-        const cleared = core.updateAiProfileAvatar({
-            workspaceId: 'workspace-1',
-            profileId: resolved.profile.id,
-            avatarUrl: null,
-            avatarSourceUrl: null
-        });
-        expect(cleared.avatarUrl).toBeNull();
-        expect(cleared.avatarSourceUrl).toBeNull();
-        expect(cleared.avatarRevision).toBe(2);
-        expect(cleared.avatarUpdatedAt).toBe(cleared.updatedAt);
-    });
-    it('seeds blank same-name runtime profiles when applying an ai profile avatar', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const local = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            icon: 'Bot',
-            color: '#0ea5e9'
-        }, { trustedSeatScope: 'local_unmetered' });
-        const cloud = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            icon: 'Bot',
-            color: '#0ea5e9'
-        }, { trustedSeatScope: 'cloud_metered' });
-        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: local.profile.id,
-            avatarUrl,
-            avatarSourceUrl
-        });
-        const profiles = core.listAiProfiles('workspace-1');
-        const refreshedLocal = profiles.find((profile) => profile.id === local.profile.id);
-        const refreshedCloud = profiles.find((profile) => profile.id === cloud.profile.id);
-        expect(refreshedLocal?.avatarUrl).toBe(avatarUrl);
-        expect(refreshedCloud?.avatarUrl).toBe(avatarUrl);
-        expect(refreshedCloud?.avatarSourceUrl).toBe(avatarSourceUrl);
-        expect(refreshedCloud?.avatarRevision).toBe(updated.avatarRevision);
-        expect(refreshedCloud?.avatarUpdatedAt).toBe(updated.avatarUpdatedAt);
-    });
-    it('repairs blank same-name runtime profile avatars on token lookup', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const local = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            icon: 'Bot',
-            color: '#0ea5e9'
-        }, { trustedSeatScope: 'local_unmetered' });
-        const cloud = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            icon: 'Bot',
-            color: '#0ea5e9'
-        }, { trustedSeatScope: 'cloud_metered' });
-        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: local.profile.id,
-            avatarUrl,
-            avatarSourceUrl
-        });
-        core.db.prepare(`
-            UPDATE ai_profiles
-            SET avatar_url = NULL,
-                avatar_source_url = NULL,
-                avatar_revision = ?
-            WHERE id = ?
-        `).run(updated.avatarRevision, cloud.profile.id);
-        const lookedUp = core.getAiProfileByToken({
-            workspaceId: 'workspace-1',
-            profileToken: cloud.profile.profileToken,
-            seatScope: 'cloud_metered'
-        });
-        expect(lookedUp?.id).toBe(cloud.profile.id);
-        expect(lookedUp?.avatarUrl).toBe(avatarUrl);
-        expect(lookedUp?.avatarSourceUrl).toBe(avatarSourceUrl);
-        expect(lookedUp?.avatarRevision).toBe(updated.avatarRevision);
-    });
-    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('does not clear synced ai profile avatars from legacy stale null sync payloads', () => {
-        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 { avatarRevision: _avatarRevision, avatarUpdatedAt: _avatarUpdatedAt, ...legacyUpdated } = updated;
-        const cleared = core.upsertAiProfileForSync({
-            ...legacyUpdated,
-            avatarUrl: null,
-            avatarSourceUrl: null,
-            updatedAt: clearedAt,
-            lastActiveAt: clearedAt
-        });
-        expect(cleared.avatarUrl).toBe(updated.avatarUrl);
-        expect(cleared.avatarSourceUrl).toBe(updated.avatarSourceUrl);
-        expect(cleared.avatarRevision).toBe(updated.avatarRevision);
-    });
-    it('does not clear synced ai profile avatars from blank revisions without avatar update timestamps', () => {
-        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 refreshedAt = new Date(Date.parse(updated.updatedAt) + 1000).toISOString();
-        const replayed = core.upsertAiProfileForSync({
-            ...updated,
-            avatarUrl: null,
-            avatarSourceUrl: null,
-            avatarRevision: (updated.avatarRevision ?? 0) + 1,
-            avatarUpdatedAt: null,
-            updatedAt: refreshedAt,
-            lastActiveAt: refreshedAt
-        });
-        expect(replayed.avatarUrl).toBe(updated.avatarUrl);
-        expect(replayed.avatarSourceUrl).toBe(updated.avatarSourceUrl);
-        expect(replayed.avatarRevision).toBe(updated.avatarRevision);
-        expect(replayed.avatarUpdatedAt).toBe(updated.avatarUpdatedAt);
-    });
-    it('clears synced ai profile avatars when sync payloads send a newer avatar revision', () => {
-        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,
-            avatarRevision: (updated.avatarRevision ?? 0) + 1,
-            avatarUpdatedAt: clearedAt,
-            updatedAt: clearedAt,
-            lastActiveAt: clearedAt
-        });
-        expect(cleared.avatarUrl).toBeNull();
-        expect(cleared.avatarSourceUrl).toBeNull();
-        expect(cleared.avatarRevision).toBe((updated.avatarRevision ?? 0) + 1);
-        expect(cleared.avatarUpdatedAt).toBe(clearedAt);
-    });
-    it('repairs blank legacy ai profile avatar pointers from workspace asset metadata', () => {
-        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: 'Felix Leiter',
-            icon: 'Bot',
-            color: '#0ea5e9'
-        });
-        const db = core.db;
-        const croppedKey = `workspaces/workspace-1/assets/images/ai-profiles/${resolved.profile.id}/avatar/asset-cropped-Felix.webp`;
-        const sourceKey = `workspaces/workspace-1/assets/images/ai-profiles/${resolved.profile.id}/avatar/asset-source-Felix.webp`;
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, logical_name, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, is_latest, scan_status,
-                created_at, updated_at
-            ) VALUES (?, 'default', 'workspace-1', 'image', ?, ?, 'image/webp', 'local', ?, ?, 100, 1, 'clean', ?, ?)
-        `).run('asset-cropped', 'Felix avatar', 'cropped-Felix.webp', croppedKey, 'sha-cropped', '2026-04-28T15:00:00.000Z', '2026-04-28T15:00:00.000Z');
-        db.prepare(`
-            INSERT INTO workspace_assets (
-                asset_id, tenant_id, workspace_id, kind, logical_name, original_filename, mime_type,
-                storage_provider, storage_key, content_sha256, size_bytes, is_latest, scan_status,
-                created_at, updated_at
-            ) VALUES (?, 'default', 'workspace-1', 'image', ?, ?, 'image/webp', 'local', ?, ?, 100, 1, 'clean', ?, ?)
-        `).run('asset-source', 'Felix source', 'source-Felix.webp', sourceKey, 'sha-source', '2026-04-28T15:01:00.000Z', '2026-04-28T15:01:00.000Z');
-        const repaired = core.listAiProfiles('workspace-1').find((profile) => profile.id === resolved.profile.id);
-        expect(repaired?.avatarUrl).toBe(`/api/taskforce/context/${encodeURIComponent(croppedKey)}`);
-        expect(repaired?.avatarSourceUrl).toBe(`/api/taskforce/context/${encodeURIComponent(sourceKey)}`);
-        expect(repaired?.avatarRevision).toBe(1);
-        expect(repaired?.avatarUpdatedAt).toBe('2026-04-28T15:00:00.000Z');
-        core.updateAiProfileAvatar({
-            workspaceId: 'workspace-1',
-            profileId: resolved.profile.id,
-            avatarUrl: null,
-            avatarSourceUrl: null
-        });
-        const cleared = core.listAiProfiles('workspace-1').find((profile) => profile.id === resolved.profile.id);
-        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);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const first = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            description: 'Builds and repairs product code',
-            role: 'Implementer',
-            provider: 'OpenAI',
-            model: 'gpt-5.4',
-            surfaceType: 'coding_tool'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            color: '#0ea5e9',
-            profileToken: first.profile.profileToken
-        });
-        expect(second.profile.description).toBe('Builds and repairs product code');
-        expect(second.profile.role).toBe('Implementer');
-        expect(second.profile.provider).toBe('OpenAI');
-        expect(second.profile.model).toBe('gpt-5.4');
-        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);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const first = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Reviewer',
-            description: 'Reviews implementation plans',
-            role: 'Reviewer',
-            provider: 'Anthropic',
-            model: 'claude-sonnet'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Reviewer',
-            description: '   ',
-            role: '',
-            provider: ' ',
-            model: '',
-            profileToken: first.profile.profileToken
-        });
-        expect(second.profile.description).toBe('Reviews implementation plans');
-        expect(second.profile.role).toBe('Reviewer');
-        expect(second.profile.provider).toBe('Anthropic');
-        expect(second.profile.model).toBe('claude-sonnet');
-    });
-    it('preserves ai profile icon and color when re-resolved without those fields', () => {
-        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: 'Codex',
-            icon: 'Sparkles',
-            color: '#0ea5e9'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex 2',
-            profileToken: first.profile.profileToken
-        });
-        expect(second.profile.icon).toBe('Sparkles');
-        expect(second.profile.color).toBe('#0ea5e9');
-    });
-    it('clears ai profile surfaceType when re-resolved with null or an empty string', () => {
-        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: 'ChatGPT',
-            surfaceType: 'chat_app'
-        });
-        const clearedWithNull = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'ChatGPT',
-            surfaceType: null,
-            profileToken: first.profile.profileToken
-        });
-        expect(clearedWithNull.profile.surfaceType).toBeNull();
-        const reset = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'ChatGPT',
-            surfaceType: 'chat_app',
-            profileToken: first.profile.profileToken
-        });
-        expect(reset.profile.surfaceType).toBe('chat_app');
-        const clearedWithEmptyString = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'ChatGPT',
-            surfaceType: '',
-            profileToken: first.profile.profileToken
-        });
-        expect(clearedWithEmptyString.profile.surfaceType).toBeNull();
-    });
-    it('preserves ai profile surfaceType when re-resolved without the field', () => {
-        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: 'Codex',
-            surfaceType: 'coding_tool'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            profileToken: first.profile.profileToken
-        });
-        expect(second.profile.surfaceType).toBe('coding_tool');
-    });
-    it('supports cli and maps legacy other surfaceType values to agent', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const cliProfile = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            surfaceType: 'cli'
-        });
-        expect(cliProfile.profile.surfaceType).toBe('cli');
-        expect(cliProfile.profile.role).toBe('CLI Coding Agent');
-        const legacyOtherProfile = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Legacy Agent',
-            surfaceType: 'other'
-        });
-        expect(legacyOtherProfile.profile.surfaceType).toBe('agent');
-    });
-    it('keeps a manually updated ai profile surfaceType from being overwritten by future registration', () => {
-        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: 'ChatGPT',
-            surfaceType: 'chat_app'
-        });
-        const updated = core.updateAiProfileSurfaceType({
-            workspaceId: 'workspace-1',
-            profileId: first.profile.id,
-            surfaceType: 'coding_tool'
-        });
-        expect(updated.surfaceType).toBe('coding_tool');
-        const replayedRegistration = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'ChatGPT',
-            surfaceType: 'chat_app',
-            profileToken: first.profile.profileToken
-        });
-        expect(replayedRegistration.profile.surfaceType).toBe('coding_tool');
-    });
-    it('treats unclassified ai profile category updates as clearing the manual override', () => {
-        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: 'ChatGPT',
-            surfaceType: 'chat_app'
-        });
-        const cleared = core.updateAiProfileSurfaceType({
-            workspaceId: 'workspace-1',
-            profileId: first.profile.id,
-            surfaceType: null
-        });
-        expect(cleared.surfaceType).toBeNull();
-        const replayedRegistration = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'ChatGPT',
-            surfaceType: 'coding_tool',
-            profileToken: first.profile.profileToken
-        });
-        expect(replayedRegistration.profile.surfaceType).toBe('coding_tool');
-    });
-    it('rejects invalid ai profile surfaceType values', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        expect(() => core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Codex',
-            surfaceType: 'desktop_app'
-        })).toThrow(/surfaceType/i);
-    });
-    it('repairs legacy ai_profiles tables that are missing newer columns', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const storageDir = path.join(projectRoot, '.taskforce');
-        fs.mkdirSync(storageDir, { recursive: true });
-        const dbPath = path.join(storageDir, 'taskforce.db');
-        const db = new Database(dbPath);
-        db.exec(`
-            CREATE TABLE ai_profiles (
-                id TEXT PRIMARY KEY,
-                tenant_id TEXT NOT NULL DEFAULT 'default',
-                workspace_id TEXT NOT NULL DEFAULT 'default',
-                profile_token TEXT NOT NULL,
-                name TEXT NOT NULL,
-                username TEXT NOT NULL,
-                icon TEXT NOT NULL,
-                color TEXT NOT NULL,
-                created_at TEXT NOT NULL,
-                updated_at TEXT NOT NULL
-            );
-        `);
-        db.prepare(`
-            INSERT INTO ai_profiles (
-                id, tenant_id, workspace_id, profile_token, name, username, icon, color, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('ai-profile-legacy-codex', 'default', 'workspace-1', 'tfp_legacy_codex', 'Codex', 'codex', 'Bot', '#0ea5e9', '2026-03-22T10:00:00.000Z', '2026-03-22T10:05:00.000Z');
-        db.close();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const profiles = core.listAiProfiles('workspace-1');
-        expect(profiles).toEqual([
-            expect.objectContaining({
-                id: 'ai-profile-legacy-codex',
-                name: 'Codex',
-                username: 'codex',
-                description: null,
-                role: null,
-                provider: null,
-                model: null,
-                surfaceType: null,
-                lastActiveAt: null
-            })
-        ]);
-    });
-    it('orders ai profiles case-insensitively without sqlite-specific collation syntax', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const sameTimestamp = '2026-03-22T12:00:00.000Z';
-        const db = core.db;
-        db.prepare(`
-            INSERT INTO ai_profiles (
-                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
-                provider_metadata_json, created_at, updated_at, last_active_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('ai-profile-zebra', 'default', 'workspace-1', 'tfp_zebra', 'zebra', 'zebra', 'Bot', '#111111', null, sameTimestamp, sameTimestamp, null);
-        db.prepare(`
-            INSERT INTO ai_profiles (
-                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
-                provider_metadata_json, created_at, updated_at, last_active_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('ai-profile-alpha', 'default', 'workspace-1', 'tfp_alpha', 'Alpha', 'alpha', 'Bot', '#222222', null, sameTimestamp, sameTimestamp, null);
-        db.prepare(`
-            INSERT INTO ai_profiles (
-                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
-                provider_metadata_json, created_at, updated_at, last_active_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        `).run('ai-profile-bravo', 'default', 'workspace-1', 'tfp_bravo', 'bravo', 'bravo', 'Bot', '#333333', null, sameTimestamp, sameTimestamp, null);
-        expect(core.listAiProfiles('workspace-1').map((profile) => profile.name)).toEqual([
-            'Alpha',
-            'bravo',
-            'zebra'
-        ]);
-    });
-    it('uses a postgres-safe ordering expression for ai profiles', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        let capturedSql = '';
-        core.db = {
-            provider: 'postgres',
-            prepare(sql) {
-                capturedSql = sql;
-                return {
-                    all() {
-                        return [];
-                    }
-                };
-            }
-        };
-        expect(core.listAiProfiles('workspace-1')).toEqual([]);
-        expect(capturedSql).toContain('LOWER(name) ASC');
-        expect(capturedSql).not.toContain('COLLATE NOCASE');
-    });
-    it('resolves actor by display name when comment author is a name rather than profile ID', () => {
-        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: 'Claude',
-            color: '#f59e0b'
-        });
-        // Resolve by name only when the alias is uniquely attributable.
-        const actorByName = core.resolveWorkspaceActor('workspace-1', 'Claude');
-        expect(actorByName).not.toBeNull();
-        expect(actorByName?.id).toBe(profile.id);
-        expect(actorByName?.kind).toBe('ai');
-        expect(actorByName?.label).toBe('Claude');
-        // Case-insensitive
-        const actorLower = core.resolveWorkspaceActor('workspace-1', 'claude');
-        expect(actorLower?.id).toBe(profile.id);
-    });
-    it('leaves duplicate ai profile aliases unresolved instead of picking one profile', () => {
-        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: 'Claude', color: '#f59e0b' });
-        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude 2', color: '#0ea5e9' });
-        const db = core.db;
-        db.prepare(`UPDATE ai_profiles SET name = 'Claude', username = 'claude' WHERE tenant_id = ? AND id = ?`)
-            .run('default', second.profile.id);
-        const actor = core.resolveWorkspaceActor('workspace-1', 'Claude');
-        expect(actor?.id).toBe('Claude');
-        expect(actor?.kind).toBe('ai');
-        expect(actor?.meta?.unresolved).toBe(true);
-        const task = core.createTask({
-            title: 'Ambiguous legacy comment author',
-            comments: [{
-                    id: 'comment-1',
-                    author: 'Claude',
-                    text: 'Keep the original ambiguous alias.',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        const fetched = core.getTask(task.id, 'workspace-1');
-        expect(fetched?.comments?.[0]?.author).toBe('Claude');
-        expect(fetched?.comments?.[0]?.actor?.id).toBe('Claude');
-        expect(fetched?.comments?.[0]?.actor?.meta?.unresolved).toBe(true);
-        expect(first.profile.id).not.toBe(second.profile.id);
-    });
-    it('classifies well-known AI model names as ai-kind even without a registered profile', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        // No profile registered, but name is a known AI model
-        const actor = core.resolveWorkspaceActor('workspace-1', 'chatgpt');
-        expect(actor?.kind).toBe('ai');
-        const actorCodex = core.resolveWorkspaceActor('workspace-1', 'codex');
-        expect(actorCodex?.kind).toBe('ai');
-        // Unknown string should default to human
-        const actorUnknown = core.resolveWorkspaceActor('workspace-1', 'randomstring123');
-        expect(actorUnknown?.kind).toBe('human');
-    });
-    it('reuses the existing profile when re-registering the same AI by exact name', () => {
-        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: 'Antigravity' });
-        expect(first.created).toBe(true);
-        expect(first.duplicateWarning).toBeUndefined();
-        // Second creation without a token should reuse instead of minting a duplicate.
-        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('reuses a stateless ai profile by name and provider while treating model changes as metadata updates', () => {
-        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: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-5',
-            surfaceType: 'chat_app'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'claude',
-            provider: 'anthropic',
-            model: 'claude-sonnet-4-6',
-            surfaceType: 'chat_app'
-        });
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(second.profile.model).toBe('claude-sonnet-4-6');
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('reuses a provider-bearing stateless ai profile when a later resolve omits provider and model', () => {
-        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: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-5',
-            surfaceType: 'chat_app'
-        });
-        const second = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'claude'
-        });
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(second.profile.provider).toBe('Anthropic');
-        expect(second.profile.model).toBe('claude-sonnet-4-5');
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('reuses same-scope ai profiles across provider drift', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const original = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Felix Leiter',
-            provider: 'OpenAI',
-            model: 'openai-codex/gpt-5.4',
-            surfaceType: 'agent'
-        });
-        const drifted = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Felix Leiter',
-            provider: 'OpenClaw',
-            model: 'gpt-5.4',
-            surfaceType: 'agent'
-        });
-        expect(drifted.created).toBe(false);
-        expect(drifted.profile.id).toBe(original.profile.id);
-        expect(drifted.profile.provider).toBe('OpenClaw');
-        expect(drifted.profile.model).toBe('gpt-5.4');
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('reuses same-scope ai profiles across surface type drift', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const chat = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-6',
-            surfaceType: 'chat_app'
-        });
-        const codingTool = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-6',
-            surfaceType: 'coding_tool'
-        });
-        expect(codingTool.created).toBe(false);
-        expect(codingTool.profile.id).toBe(chat.profile.id);
-        expect(codingTool.profile.surfaceType).toBe('coding_tool');
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('reuses same-scope ai profiles when reconnecting with a stale token', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const original = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Tiffany Case',
-            provider: 'openai-codex',
-            model: 'gpt-5.4',
-            surfaceType: 'agent'
-        }, { trustedSeatScope: 'cloud_metered' });
-        const reconnected = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Tiffany Case',
-            profileToken: 'tfp_stale_tiffany_case_token',
-            provider: 'OpenAI Codex',
-            model: 'openai-codex/gpt-5.4',
-            surfaceType: 'agent'
-        }, { trustedSeatScope: 'cloud_metered' });
-        expect(reconnected.created).toBe(false);
-        expect(reconnected.profile.id).toBe(original.profile.id);
-        expect(reconnected.profile.provider).toBe('OpenAI Codex');
-        expect(reconnected.profile.model).toBe('openai-codex/gpt-5.4');
-        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
-    });
-    it('prefers the most recently active matching ai profile when stateless candidates are duplicated', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const older = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-5',
-            surfaceType: 'chat_app'
-        });
-        const newer = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude Duplicate',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-6',
-            surfaceType: 'chat_app'
-        });
-        core.db.prepare(`
-            UPDATE ai_profiles
-            SET name = 'Claude',
-                username = 'claude',
-                last_active_at = CASE id
-                    WHEN ? THEN '2026-04-01T00:00:00.000Z'
-                    ELSE '2026-04-02T00:00:00.000Z'
-                END,
-                updated_at = CASE id
-                    WHEN ? THEN '2026-04-01T00:00:00.000Z'
-                    ELSE '2026-04-02T00:00:00.000Z'
-                END
-            WHERE id IN (?, ?)
-        `).run(older.profile.id, older.profile.id, older.profile.id, newer.profile.id);
-        const resolved = core.resolveAiProfile({
-            workspaceId: 'workspace-1',
-            name: 'Claude',
-            provider: 'Anthropic',
-            model: 'claude-sonnet-4-7',
-            surfaceType: 'chat_app'
-        });
-        expect(resolved.created).toBe(false);
-        expect(resolved.profile.id).toBe(newer.profile.id);
-        expect(resolved.duplicateWarning?.existingProfileId).toBe(newer.profile.id);
-    });
-    it('reuses Codex by exact name without leaking across workspaces', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        core.createWorkspace({ workspaceId: 'workspace-2', name: 'Workspace 2' });
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
-        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
-        const otherWorkspace = core.resolveAiProfile({ workspaceId: 'workspace-2', name: 'Codex' });
-        expect(first.created).toBe(true);
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(otherWorkspace.created).toBe(true);
-        expect(otherWorkspace.profile.id).not.toBe(first.profile.id);
-        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);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
-        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity Clone' });
-        // Create a task assigned to the duplicate and a comment authored by it
-        const task = core.createTask({
-            title: 'Task with duplicate assignee',
-            assignee: second.profile.id,
-            comments: [{
-                    id: 'c1',
-                    author: second.profile.id,
-                    text: 'Comment from duplicate',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        // Merge the duplicate into the original
-        const merged = core.mergeAiProfiles({
-            workspaceId: 'workspace-1',
-            keepId: first.profile.id,
-            mergeId: second.profile.id
-        });
-        expect(merged.id).toBe(first.profile.id);
-        // 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('does not merge separate local and cloud AI profile registrations', () => {
-        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(() => core.mergeAiProfiles({
-            workspaceId: 'workspace-1',
-            keepId: local.profile.id,
-            mergeId: cloud.profile.id
-        })).toThrow(/separate registrations/);
-        expect(core.listAiProfiles('workspace-1').map((profile) => profile.id).sort()).toEqual([cloud.profile.id, local.profile.id].sort());
-    });
-    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);
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const resolved = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'ChatGPT', color: '#10a37f' });
-        const task = core.createTask({
-            title: 'Canonicalize actor refs',
-            createdBy: 'chatgpt',
-            assignee: 'ChatGPT',
-            comments: [{
-                    id: 'c1',
-                    author: 'chatgpt',
-                    text: 'Stored as canonical profile id',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        const fetched = core.getTask(task.id, 'workspace-1');
-        expect(fetched?.createdBy).toBe(resolved.profile.id);
-        expect(fetched?.assignee).toBe(resolved.profile.id);
-        expect(fetched?.comments?.[0]?.author).toBe(resolved.profile.id);
-        expect(fetched?.comments?.[0]?.submittedAuthor).toBe('chatgpt');
-        expect(fetched?.assigneeActor?.label).toBe('ChatGPT');
-        expect(fetched?.comments?.[0]?.actor?.label).toBe('ChatGPT');
-    });
-    it('keeps ambiguous legacy AI comment aliases unresolved instead of rebinding them', () => {
-        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' });
-        const task = core.createTask({
-            title: 'Ambiguous legacy comment alias',
-            comments: [{
-                    id: 'legacy-codex',
-                    author: 'codex',
-                    text: 'Leave me unresolved',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        const fetched = core.getTask(task.id, 'workspace-1');
-        expect(fetched?.comments?.[0]?.author).toBe('codex');
-        expect(fetched?.comments?.[0]?.actor).toEqual(expect.objectContaining({
-            id: 'codex',
-            kind: 'ai',
-            label: 'Codex',
-            meta: expect.objectContaining({ unresolved: true })
-        }));
-        expect(fetched?.comments?.[0]?.actor?.id).not.toBe(cloud.profile.id);
-        expect(fetched?.comments?.[0]?.actor?.id).not.toBe(local.profile.id);
-    });
-    it('repairs legacy comments from submittedAuthor under the v2 migration even after v1 completed', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const firstCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        firstCore.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const resolved = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude', color: '#f59e0b' });
-        const task = firstCore.createTask({
-            title: 'Repair legacy submitted author',
-            comments: [{
-                    id: 'legacy-agent',
-                    author: 'agent',
-                    submittedAuthor: 'Claude',
-                    text: 'Legacy comment should repair forward',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        const firstDb = firstCore.db;
-        const originalTaskWatermark = '2026-03-22T10:00:00.000Z';
-        firstDb.prepare(`
-            UPDATE tasks
-            SET updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).run(originalTaskWatermark, 'default', 'workspace-1', task.id);
-        const completedAt = '2026-03-22T11:00:00.000Z';
-        firstDb.prepare(`
-            INSERT INTO system_settings (tenant_id, settings_key, payload, updated_at)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT (tenant_id, settings_key) DO UPDATE SET
-                payload = excluded.payload,
-                updated_at = excluded.updated_at
-        `).run('default', 'migration.actor_refs.canonicalize.v1', JSON.stringify({ completedAt }), completedAt);
-        firstDb.prepare(`
-            DELETE FROM system_settings
-            WHERE tenant_id = ? AND settings_key = ?
-        `).run('default', 'migration.actor_refs.canonicalize_comments.v2');
-        firstCore.close();
-        const secondCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const fetched = secondCore.getTask(task.id, 'workspace-1');
-        expect(fetched?.comments?.[0]?.author).toBe(resolved.profile.id);
-        expect(fetched?.comments?.[0]?.submittedAuthor).toBe('Claude');
-        expect(fetched?.comments?.[0]?.actor?.id).toBe(resolved.profile.id);
-        expect(Date.parse(String(fetched?.updatedAt || ''))).toBeGreaterThan(Date.parse(originalTaskWatermark));
-        const syncRows = secondCore.listTasksForSync('workspace-1', {
-            watermark: originalTaskWatermark,
-            id: task.id,
-        }, 10);
-        expect(syncRows).toHaveLength(1);
-        expect(syncRows[0]?.task?.id).toBe(task.id);
-        expect(syncRows[0]?.task?.comments?.[0]?.author).toBe(resolved.profile.id);
-        const secondDb = secondCore.db;
-        const migrationRow = secondDb.prepare(`
-            SELECT payload
-            FROM system_settings
-            WHERE tenant_id = ? AND settings_key = ?
-            LIMIT 1
-        `).get('default', 'migration.actor_refs.canonicalize_comments.v2');
-        expect(JSON.parse(String(migrationRow?.payload || '{}'))).toEqual(expect.objectContaining({
-            repairedCount: 1,
-            ambiguousCount: 0,
-            skippedCount: expect.any(Number)
-        }));
-        secondCore.close();
-    });
-    it('keeps repaired legacy comment sync watermarks monotonic when a task watermark is already ahead of local now', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const firstCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        firstCore.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const resolved = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude', color: '#f59e0b' });
-        const task = firstCore.createTask({
-            title: 'Repair legacy submitted author with future watermark',
-            comments: [{
-                    id: 'legacy-agent-future',
-                    author: 'agent',
-                    submittedAuthor: 'Claude',
-                    text: 'Legacy comment should repair without moving sync backwards',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        const firstDb = firstCore.db;
-        const originalTaskWatermark = '2099-03-22T10:00:00.000Z';
-        firstDb.prepare(`
-            UPDATE tasks
-            SET updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).run(originalTaskWatermark, 'default', 'workspace-1', task.id);
-        const completedAt = '2026-03-22T11:00:00.000Z';
-        firstDb.prepare(`
-            INSERT INTO system_settings (tenant_id, settings_key, payload, updated_at)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT (tenant_id, settings_key) DO UPDATE SET
-                payload = excluded.payload,
-                updated_at = excluded.updated_at
-        `).run('default', 'migration.actor_refs.canonicalize.v1', JSON.stringify({ completedAt }), completedAt);
-        firstDb.prepare(`
-            DELETE FROM system_settings
-            WHERE tenant_id = ? AND settings_key = ?
-        `).run('default', 'migration.actor_refs.canonicalize_comments.v2');
-        firstCore.close();
-        const secondCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const fetched = secondCore.getTask(task.id, 'workspace-1');
-        expect(fetched?.comments?.[0]?.author).toBe(resolved.profile.id);
-        expect(Date.parse(String(fetched?.updatedAt || ''))).toBeGreaterThan(Date.parse(originalTaskWatermark));
-        const syncRows = secondCore.listTasksForSync('workspace-1', {
-            watermark: originalTaskWatermark,
-            id: task.id,
-        }, 10);
-        expect(syncRows).toHaveLength(1);
-        expect(syncRows[0]?.task?.id).toBe(task.id);
-        expect(syncRows[0]?.task?.comments?.[0]?.author).toBe(resolved.profile.id);
-        secondCore.close();
-    });
-    it('repairs legacy actor refs and merges duplicate ai profiles on startup', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const firstCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        firstCore.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const firstDb = firstCore.db;
-        const first = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
-        const second = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity Clone' });
-        firstDb.prepare(`UPDATE ai_profiles SET name = 'Antigravity', username = 'antigravity' WHERE tenant_id = ? AND id = ?`)
-            .run('default', second.profile.id);
-        firstDb.prepare(`DELETE FROM system_settings WHERE tenant_id = ? AND settings_key IN (?, ?)`)
-            .run('default', 'migration.ai_profiles.dedupe.v1', 'migration.actor_refs.canonicalize.v1');
-        const task = firstCore.createTask({
-            title: 'Legacy actor refs',
-            createdBy: 'claude',
-            assignee: 'antigravity',
-            comments: [
-                {
-                    id: 'legacy-comment',
-                    author: 'claude',
-                    text: 'Legacy claude alias',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }
-            ]
-        }, { workspaceId: 'workspace-1' });
-        const claude = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' });
-        expect(task.comments?.[0]?.author).toBe('claude');
-        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(['Antigravity', 'Claude']);
-        const survivingAntigravityId = profiles.find((profile) => profile.name === 'Antigravity')?.id;
-        expect(reloaded?.createdBy).toBe(claude.profile.id);
-        expect(reloaded?.assignee).toBe(survivingAntigravityId);
-        expect(reloaded?.comments?.[0]?.author).toBe(claude.profile.id);
-        expect(reloaded?.comments?.[0]?.actor?.label).toBe('Claude');
-    });
-    it('does not repair ambiguous legacy comment authors on startup', () => {
-        const projectRoot = createProjectRoot();
-        createdRoots.push(projectRoot);
-        const firstCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        firstCore.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        const firstDb = firstCore.db;
-        const first = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude', color: '#f59e0b' });
-        const second = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude 2', color: '#0ea5e9' });
-        const task = firstCore.createTask({
-            title: 'Ambiguous legacy actor refs',
-            comments: [{
-                    id: 'legacy-comment',
-                    author: first.profile.id,
-                    text: 'Leave ambiguous alias untouched.',
-                    timestamp: '2026-03-22T10:00:00.000Z'
-                }]
-        }, { workspaceId: 'workspace-1' });
-        firstDb.prepare(`UPDATE ai_profiles SET name = 'Claude', username = 'claude' WHERE tenant_id = ? AND id = ?`)
-            .run('default', second.profile.id);
-        firstDb.prepare(`UPDATE comments SET author = 'claude', submitted_author = 'claude' WHERE tenant_id = ? AND task_id = ? AND id = ?`)
-            .run('default', task.id, 'legacy-comment');
-        firstDb.prepare(`DELETE FROM system_settings WHERE tenant_id = ? AND settings_key = ?`)
-            .run('default', 'migration.actor_refs.canonicalize.v1');
-        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const reloaded = reloadedCore.getTask(task.id, 'workspace-1');
-        expect(reloaded?.comments?.[0]?.author).toBe('claude');
-        expect(reloaded?.comments?.[0]?.submittedAuthor).toBe('claude');
-        expect(reloaded?.comments?.[0]?.actor?.meta?.unresolved).toBe(true);
-        expect(reloaded?.comments?.[0]?.actor?.label).toBe('Claude');
-    });
-});