@taskforcehq/taskforce 0.3.305 → 0.3.307

package/dist/core/AiProfiles.test.js

@@ -73,6 +73,9 @@ describe('TaskforceCore ai profiles', () => {
         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();
@@ -98,6 +101,319 @@ describe('TaskforceCore ai profiles', () => {
         expect(second.profile.icon).toBe('Sparkles');
         expect(second.profile.color).toBe('#0ea5e9');
     });
+    it('updates ai profile avatar urls without changing the registered icon fallback', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#0ea5e9'
+        });
+        const avatarUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Favatar.webp';
+        const avatarSourceUrl = '/api/taskforce/context/workspaces%2Fworkspace-1%2Fassets%2Fimages%2Fai-profiles%2Fprofile%2Favatar%2Fsource.webp';
+        const updated = core.updateAiProfileAvatar({
+            workspaceId: 'workspace-1',
+            profileId: resolved.profile.id,
+            avatarUrl,
+            avatarSourceUrl
+        });
+        expect(updated.avatarUrl).toBe(avatarUrl);
+        expect(updated.avatarSourceUrl).toBe(avatarSourceUrl);
+        expect(updated.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);
@@ -339,6 +655,73 @@ describe('TaskforceCore ai profiles', () => {
         });
         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);
@@ -454,7 +837,7 @@ describe('TaskforceCore ai profiles', () => {
             name: 'Claude',
             color: '#f59e0b'
         });
-        // Resolve by name (e.g. agent passed "Claude" as author instead of profile ID)
+        // 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);
@@ -464,6 +847,35 @@ describe('TaskforceCore ai profiles', () => {
         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);
@@ -492,82 +904,398 @@ describe('TaskforceCore ai profiles', () => {
         expect(second.profile.id).toBe(first.profile.id);
         expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
     });
-    it('reuses Codex by exact name without leaking across workspaces', () => {
+    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' });
-        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);
+        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(otherWorkspace.created).toBe(true);
-        expect(otherWorkspace.profile.id).not.toBe(first.profile.id);
+        expect(second.profile.model).toBe('claude-sonnet-4-6');
         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', () => {
+    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' });
-        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
+        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: 'Codex Prime',
-            icon: 'Sparkles',
-            profileToken: first.profile.profileToken
+            name: 'claude'
         });
         expect(second.created).toBe(false);
         expect(second.profile.id).toBe(first.profile.id);
-        expect(second.profile.name).toBe('Codex Prime');
+        expect(second.profile.provider).toBe('Anthropic');
+        expect(second.profile.model).toBe('claude-sonnet-4-5');
         expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
     });
-    it('reuses an exact-match ai profile even when the ai profile limit is full', () => {
+    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' });
-        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Automation Codex' });
-        const second = core.resolveAiProfile({
+        const original = core.resolveAiProfile({
             workspaceId: 'workspace-1',
-            name: 'Automation Codex',
-            role: 'Assistant'
+            name: 'Felix Leiter',
+            provider: 'OpenAI',
+            model: 'openai-codex/gpt-5.4',
+            surfaceType: 'agent'
         });
-        expect(second.created).toBe(false);
-        expect(second.profile.id).toBe(first.profile.id);
-        expect(second.profile.role).toBe('Assistant');
+        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('blocks net-new ai profile creation when the ai profile limit is full', () => {
+    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' });
-        enableAiProfileSeatLimit(core, 'workspace-1', 'owner-u1', 1);
-        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
-        expect(first.created).toBe(true);
-        try {
-            core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' });
-            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,
+        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);
@@ -593,16 +1321,324 @@ describe('TaskforceCore ai profiles', () => {
             mergeId: second.profile.id
         });
         expect(merged.id).toBe(first.profile.id);
-        // Duplicate profile should be gone
+        // Duplicate profile should leave the active roster but remain archived for history and sync.
         const profiles = core.listAiProfiles('workspace-1');
         expect(profiles.some((p) => p.id === second.profile.id)).toBe(false);
         expect(profiles.some((p) => p.id === first.profile.id)).toBe(true);
+        const archivedProfiles = core.listAiProfiles('workspace-1', { includeArchived: true });
+        const archivedDuplicate = archivedProfiles.find((p) => p.id === second.profile.id);
+        expect(archivedDuplicate).toMatchObject({
+            id: second.profile.id,
+            archivedReason: 'merged_duplicate',
+            mergedIntoProfileId: first.profile.id,
+            archivedBy: first.profile.id
+        });
+        expect(archivedDuplicate?.archivedAt).toBeTruthy();
         // Task assignee should point to the kept profile
         const updatedTask = core.getTask(task.id, 'workspace-1');
         expect(updatedTask?.assignee).toBe(first.profile.id);
         // Comment author should point to the kept profile
         expect(updatedTask?.comments?.[0]?.author).toBe(first.profile.id);
     });
+    it('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);
@@ -628,6 +1664,145 @@ describe('TaskforceCore ai profiles', () => {
         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);
@@ -658,11 +1833,41 @@ describe('TaskforceCore ai profiles', () => {
         const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
         const reloaded = reloadedCore.getTask(task.id, 'workspace-1');
         const profiles = reloadedCore.listAiProfiles('workspace-1');
-        expect(profiles.map((profile) => profile.name)).toEqual(['Claude', 'Antigravity']);
+        expect(profiles.map((profile) => profile.name)).toEqual(['Antigravity', 'Claude']);
         const survivingAntigravityId = profiles.find((profile) => profile.name === 'Antigravity')?.id;
         expect(reloaded?.createdBy).toBe(claude.profile.id);
         expect(reloaded?.assignee).toBe(survivingAntigravityId);
         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');
+    });
 });