@taskforcehq/taskforce 0.3.306 → 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();
@@ -119,9 +122,13 @@ describe('TaskforceCore ai profiles', () => {
         });
         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,
@@ -130,6 +137,84 @@ describe('TaskforceCore ai profiles', () => {
         });
         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();
@@ -162,7 +247,69 @@ describe('TaskforceCore ai profiles', () => {
         expect(replayed.avatarUrl).toBe(avatarUrl);
         expect(replayed.avatarSourceUrl).toBe(avatarSourceUrl);
     });
-    it('clears synced ai profile avatars when sync payloads explicitly send null avatar fields', () => {
+    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' });
@@ -184,11 +331,58 @@ describe('TaskforceCore ai profiles', () => {
             ...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();
@@ -461,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);
@@ -576,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);
@@ -586,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);
@@ -614,6 +904,171 @@ describe('TaskforceCore ai profiles', () => {
         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);
@@ -885,6 +1340,28 @@ describe('TaskforceCore ai profiles', () => {
         // 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);
@@ -1187,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);
@@ -1224,4 +1840,34 @@ describe('TaskforceCore ai profiles', () => {
         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');
+    });
 });