@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/core/AiProfileService.js

@@ -1,4 +1,16 @@
 import { isAiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { isAiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
+import { normalizeSyncSameOriginAssetUrl } from '../sync/syncFieldSemantics.js';
+function normalizeNullableIsoString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizeNullableProfileReference(value) {
+    const normalized = String(value || '').trim();
+    return normalized.length > 0 ? normalized : null;
+}
 function normalizeOptionalProfileField(value) {
     if (value === undefined)
         return undefined;
@@ -7,6 +19,34 @@ function normalizeOptionalProfileField(value) {
     const normalized = String(value).trim();
     return normalized.length > 0 ? normalized : undefined;
 }
+function normalizeAiProfileAvatarUrl(value) {
+    return normalizeSyncSameOriginAssetUrl(value);
+}
+function compareIsoStrings(left, right) {
+    const normalizedLeft = normalizeNullableIsoString(left);
+    const normalizedRight = normalizeNullableIsoString(right);
+    if (!normalizedLeft && !normalizedRight)
+        return 0;
+    if (!normalizedLeft)
+        return -1;
+    if (!normalizedRight)
+        return 1;
+    return normalizedLeft.localeCompare(normalizedRight);
+}
+function deriveRosterStateUpdatedAt(value, fallbacks) {
+    const explicitValue = normalizeNullableIsoString(value);
+    const archivedAt = normalizeNullableIsoString(fallbacks.archivedAt);
+    const createdAt = normalizeNullableIsoString(fallbacks.createdAt);
+    if (archivedAt) {
+        return explicitValue && compareIsoStrings(explicitValue, archivedAt) >= 0
+            ? explicitValue
+            : archivedAt;
+    }
+    // Legacy active snapshots may carry fresh metadata updatedAt values without
+    // carrying an intentional roster lifecycle event. Treat creation as the
+    // active lifecycle baseline so metadata-only sync cannot resurrect archives.
+    return explicitValue ?? createdAt;
+}
 function normalizeAiProfileSurfaceTypeInput(deps, value) {
     if (value === undefined)
         return undefined;
@@ -23,8 +63,218 @@ function normalizeAiProfileSurfaceTypeInput(deps, value) {
     }
     return normalized;
 }
-export function listAiProfilesService(deps, workspaceId) {
+function normalizeAiProfileSeatScopeInput(deps, value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== 'string') {
+        throw deps.createRuleError('AI profile seatScope must be cloud_metered or local_unmetered', 400, 'AI_PROFILE_SEAT_SCOPE_INVALID');
+    }
+    const normalized = value.trim();
+    if (!normalized)
+        return null;
+    if (!isAiProfileSeatScope(normalized)) {
+        throw deps.createRuleError('AI profile seatScope must be cloud_metered or local_unmetered', 400, 'AI_PROFILE_SEAT_SCOPE_INVALID');
+    }
+    return normalized;
+}
+function resolveAiProfileSeatScope(deps, inputSeatScope, existing) {
+    const incomingSeatScope = normalizeAiProfileSeatScopeInput(deps, inputSeatScope);
+    const existingSeatScope = existing?.seatScope ?? null;
+    if (incomingSeatScope === undefined) {
+        return {
+            seatScope: existingSeatScope,
+            seatScopeProvided: false,
+        };
+    }
+    if (incomingSeatScope === 'cloud_metered' || existingSeatScope === 'cloud_metered') {
+        return {
+            seatScope: 'cloud_metered',
+            seatScopeProvided: true,
+        };
+    }
+    return {
+        seatScope: incomingSeatScope ?? existingSeatScope,
+        seatScopeProvided: true,
+    };
+}
+function resolveSyncedAiProfileSeatScope(deps, inputSeatScope, existing) {
+    const incomingSeatScope = normalizeAiProfileSeatScopeInput(deps, inputSeatScope);
+    const existingSeatScope = existing?.seatScope ?? null;
+    if (incomingSeatScope === undefined) {
+        return {
+            seatScope: existingSeatScope,
+            seatScopeProvided: false,
+        };
+    }
+    return {
+        seatScope: incomingSeatScope ?? existingSeatScope,
+        seatScopeProvided: true,
+    };
+}
+function resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, existing) {
+    const normalizedTrustedSeatScope = normalizeAiProfileSeatScopeInput(deps, trustedSeatScope);
+    if (normalizedTrustedSeatScope === undefined) {
+        return {
+            seatScope: existing?.seatScope ?? null,
+            seatScopeProvided: false,
+        };
+    }
+    return {
+        seatScope: normalizedTrustedSeatScope,
+        seatScopeProvided: true,
+    };
+}
+function aiProfileMatchesTrustedSeatScope(deps, row, trustedSeatScope) {
+    if (trustedSeatScope === undefined)
+        return true;
+    const profile = deps.aiProfileRowToRecord(row);
+    const profileSeatScope = profile.seatScope ?? null;
+    if (profileSeatScope === null)
+        return true;
+    return profileSeatScope === trustedSeatScope;
+}
+function findFirstAiProfileRowForTrustedSeatScope(deps, rows, trustedSeatScope) {
+    if (trustedSeatScope === undefined)
+        return rows[0];
+    return rows.find((row) => aiProfileMatchesTrustedSeatScope(deps, row, trustedSeatScope));
+}
+function filterAiProfileRowsForTrustedSeatScope(deps, rows, trustedSeatScope) {
+    if (trustedSeatScope === undefined)
+        return rows;
+    return rows.filter((row) => aiProfileMatchesTrustedSeatScope(deps, row, trustedSeatScope));
+}
+function requiresCloudSeatReservation(existing, nextSeatScope) {
+    if (nextSeatScope !== 'cloud_metered')
+        return false;
+    if (existing?.archivedAt)
+        return true;
+    return existing?.seatScope !== 'cloud_metered';
+}
+function assertAiProfileSeatAvailable(deps, workspaceId) {
+    const aiProfileUsage = deps.countAiProfileUsage(workspaceId);
+    if (aiProfileUsage.limit !== null && aiProfileUsage.used >= aiProfileUsage.limit) {
+        throw deps.createRuleError('No AI seats are available for this workspace. Remove an existing cloud AI profile or upgrade your plan.', 403, 'AI_PROFILE_LIMIT_REACHED', {
+            workspaceId,
+            limit: aiProfileUsage.limit,
+            used: aiProfileUsage.used,
+            remaining: aiProfileUsage.remaining
+        });
+    }
+}
+function inferAiProfileProviderModelDefaults(name) {
+    const normalized = String(name || '').trim().toLowerCase();
+    if (!normalized)
+        return {};
+    if (normalized.includes('claude code'))
+        return { provider: 'Anthropic', model: 'Claude Code' };
+    if (normalized.includes('claude'))
+        return { provider: 'Anthropic', model: 'Claude' };
+    if (normalized.includes('chatgpt'))
+        return { provider: 'OpenAI', model: 'ChatGPT' };
+    if (normalized.includes('codex'))
+        return { provider: 'OpenAI', model: 'Codex' };
+    if (normalized.includes('gemini'))
+        return { provider: 'Google', model: 'Gemini' };
+    return {};
+}
+function inferAiProfileMetadataDefaults(name, surfaceType) {
+    const inferredProviderModel = inferAiProfileProviderModelDefaults(name);
+    switch (surfaceType) {
+        case 'agent':
+            return {
+                description: `${name} AI collaborator registered in Taskforce.`,
+                role: 'AI Collaborator',
+                ...inferredProviderModel
+            };
+        case 'coding_tool':
+            return {
+                description: `${name} coding agent connected through MCP.`,
+                role: 'Coding Agent',
+                ...inferredProviderModel
+            };
+        case 'chat_app':
+            return {
+                description: `${name} conversational AI connected through Taskforce.`,
+                role: 'AI Assistant',
+                ...inferredProviderModel
+            };
+        case 'ide':
+            return {
+                description: `${name} IDE-connected AI assistant.`,
+                role: 'Coding Assistant',
+                ...inferredProviderModel
+            };
+        case 'other':
+            return {
+                description: `${name} AI profile connected through Taskforce.`,
+                role: 'AI Assistant',
+                ...inferredProviderModel
+            };
+        default:
+            return {};
+    }
+}
+function resolveOptionalProfileField(inputValue, existingValue, fallbackValue) {
+    const explicitValue = normalizeOptionalProfileField(inputValue);
+    if (explicitValue !== undefined)
+        return explicitValue;
+    const preservedValue = normalizeOptionalProfileField(existingValue);
+    if (preservedValue !== undefined)
+        return preservedValue;
+    return normalizeOptionalProfileField(fallbackValue);
+}
+function resolveAiProfileMetadataFields(deps, input, existing) {
+    const surfaceTypeInput = normalizeAiProfileSurfaceTypeInput(deps, input.surfaceType);
+    const effectiveSurfaceType = surfaceTypeInput === undefined
+        ? existing?.surfaceType ?? null
+        : surfaceTypeInput;
+    const inferredDefaults = inferAiProfileMetadataDefaults(input.name, effectiveSurfaceType);
+    return {
+        description: resolveOptionalProfileField(input.description, existing?.description, inferredDefaults.description) ?? null,
+        role: resolveOptionalProfileField(input.role, existing?.role, inferredDefaults.role) ?? null,
+        provider: resolveOptionalProfileField(input.provider, existing?.provider, inferredDefaults.provider) ?? null,
+        model: resolveOptionalProfileField(input.model, existing?.model, inferredDefaults.model) ?? null,
+        surfaceType: effectiveSurfaceType,
+        surfaceTypeProvided: surfaceTypeInput !== undefined,
+    };
+}
+function applyAiProfileMetadataDefaults(record) {
+    const inferredDefaults = inferAiProfileMetadataDefaults(record.name, record.surfaceType);
+    return {
+        ...record,
+        description: resolveOptionalProfileField(undefined, record.description, inferredDefaults.description) ?? null,
+        role: resolveOptionalProfileField(undefined, record.role, inferredDefaults.role) ?? null,
+        provider: resolveOptionalProfileField(undefined, record.provider, inferredDefaults.provider) ?? null,
+        model: resolveOptionalProfileField(undefined, record.model, inferredDefaults.model) ?? null,
+    };
+}
+function hydrateAiProfileRecord(deps, row, diagnostics) {
+    const record = deps.aiProfileRowToRecord(row);
+    const hydrated = applyAiProfileMetadataDefaults(record);
+    const metadataChanged = record.description !== hydrated.description
+        || record.role !== hydrated.role
+        || record.provider !== hydrated.provider
+        || record.model !== hydrated.model;
+    if (metadataChanged) {
+        deps.db.prepare(`
+            UPDATE ai_profiles
+            SET description = ?,
+                role = ?,
+                provider = ?,
+                model = ?
+            WHERE tenant_id = ? AND id = ?
+        `).run(hydrated.description ?? null, hydrated.role ?? null, hydrated.provider ?? null, hydrated.model ?? null, deps.tenantId, record.id);
+        if (diagnostics) {
+            diagnostics.metadataBackfillCount = (diagnostics.metadataBackfillCount || 0) + 1;
+        }
+    }
+    return hydrated;
+}
+export function listAiProfilesService(deps, workspaceId, options) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const includeArchived = options?.includeArchived === true;
     const rows = deps.db.prepare(`
         SELECT
             id,
@@ -34,36 +284,49 @@ export function listAiProfilesService(deps, workspaceId) {
             username,
             icon,
             color,
+            avatar_url,
+            avatar_source_url,
             description,
             role,
             provider,
             model,
             surface_type,
+            seat_scope,
             provider_metadata_json,
+            archived_at,
+            archived_by,
+            archived_reason,
+            merged_into_profile_id,
+            roster_state_updated_at,
             created_at,
             updated_at,
             last_active_at
         FROM ai_profiles
         WHERE tenant_id = ?
           AND workspace_id = ?
+          AND (? = 1 OR archived_at IS NULL)
         ORDER BY COALESCE(updated_at, created_at) DESC, LOWER(name) ASC
-    `).all(deps.tenantId, normalizedWorkspaceId);
-    return rows.map((row) => deps.aiProfileRowToRecord(row));
+    `).all(deps.tenantId, normalizedWorkspaceId, includeArchived ? 1 : 0);
+    return rows.map((row) => hydrateAiProfileRecord(deps, row, options?.diagnostics));
 }
 export function getAiProfileByTokenService(deps, input) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
     const profileToken = String(input.profileToken || '').trim();
+    const includeArchived = input.includeArchived === true;
+    const trustedSeatScope = normalizeAiProfileSeatScopeInput(deps, input.seatScope);
     if (!profileToken)
         return null;
-    const row = deps.db.prepare(`
+    const rows = deps.db.prepare(`
         SELECT *
         FROM ai_profiles
         WHERE tenant_id = ?
           AND workspace_id = ?
           AND profile_token = ?
-        LIMIT 1
-    `).get(deps.tenantId, normalizedWorkspaceId, profileToken);
-    return row ? deps.aiProfileRowToRecord(row) : null;
+          AND (? = 1 OR archived_at IS NULL)
+        ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId, profileToken, includeArchived ? 1 : 0);
+    const row = findFirstAiProfileRowForTrustedSeatScope(deps, rows, trustedSeatScope);
+    return row ? hydrateAiProfileRecord(deps, row) : null;
 }
 export function upsertAiProfileForSyncService(deps, profile) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(profile.workspaceId);
@@ -77,24 +340,144 @@ export function upsertAiProfileForSyncService(deps, profile) {
     const normalizedLastActiveAt = typeof profile.lastActiveAt === 'string' && profile.lastActiveAt.trim().length > 0
         ? profile.lastActiveAt.trim()
         : null;
-    const normalizedSurfaceType = normalizeAiProfileSurfaceTypeInput(deps, profile.surfaceType);
+    const normalizedArchivedAt = normalizeNullableIsoString(profile.archivedAt);
+    const normalizedArchivedBy = normalizeNullableProfileReference(profile.archivedBy);
+    const normalizedArchivedReason = normalizeOptionalProfileField(profile.archivedReason) ?? null;
+    const normalizedMergedIntoProfileId = normalizeNullableProfileReference(profile.mergedIntoProfileId);
+    const normalizedRosterStateUpdatedAt = deriveRosterStateUpdatedAt(profile.rosterStateUpdatedAt, {
+        archivedAt: normalizedArchivedAt,
+        createdAt: normalizedCreatedAt,
+        updatedAt: normalizedUpdatedAt,
+    });
     const existingRow = deps.db.prepare(`
         SELECT *
         FROM ai_profiles
         WHERE tenant_id = ? AND workspace_id = ? AND id = ?
         LIMIT 1
     `).get(deps.tenantId, normalizedWorkspaceId, profileId);
-    if (existingRow) {
-        const existingUpdatedAt = String(existingRow.updated_at || existingRow.created_at || '').trim();
-        if (existingUpdatedAt && existingUpdatedAt > normalizedUpdatedAt) {
-            return deps.aiProfileRowToRecord(existingRow);
+    const existingProfile = existingRow ? deps.aiProfileRowToRecord(existingRow) : null;
+    const incomingAvatarUrlProvided = Object.prototype.hasOwnProperty.call(profile, 'avatarUrl');
+    const incomingAvatarSourceUrlProvided = Object.prototype.hasOwnProperty.call(profile, 'avatarSourceUrl');
+    const existingCreatedAt = existingRow
+        ? String(existingRow.created_at || existingRow.updated_at || '').trim()
+        : '';
+    const existingUpdatedAt = existingRow
+        ? String(existingRow.updated_at || existingRow.created_at || '').trim()
+        : '';
+    const existingLastActiveAt = existingRow
+        ? normalizeNullableIsoString(existingRow.last_active_at)
+        : null;
+    const existingArchivedAt = existingRow
+        ? normalizeNullableIsoString(existingRow.archived_at)
+        : null;
+    const existingArchivedBy = existingRow
+        ? normalizeNullableProfileReference(existingRow.archived_by)
+        : null;
+    const existingArchivedReason = existingRow
+        ? normalizeOptionalProfileField(existingRow.archived_reason) ?? null
+        : null;
+    const existingMergedIntoProfileId = existingRow
+        ? normalizeNullableProfileReference(existingRow.merged_into_profile_id)
+        : null;
+    const existingRosterStateUpdatedAt = existingRow
+        ? deriveRosterStateUpdatedAt(existingRow.roster_state_updated_at, {
+            archivedAt: existingArchivedAt,
+            createdAt: existingCreatedAt,
+            updatedAt: existingUpdatedAt,
+        })
+        : null;
+    const metadataComparison = compareIsoStrings(normalizedUpdatedAt, existingUpdatedAt);
+    const incomingMetadataWins = !existingRow || metadataComparison > 0;
+    const lifecycleComparison = compareIsoStrings(normalizedRosterStateUpdatedAt, existingRosterStateUpdatedAt);
+    const incomingArchived = normalizedArchivedAt !== null;
+    const existingArchived = existingArchivedAt !== null;
+    const incomingLifecycleWins = !existingRow
+        || lifecycleComparison > 0
+        || (lifecycleComparison === 0 && incomingArchived && !existingArchived);
+    const metadataSourceProfile = incomingMetadataWins
+        ? {
+            id: profileId,
+            workspaceId: normalizedWorkspaceId,
+            profileToken: String(profile.profileToken || '').trim(),
+            name: deps.normalizeAiProfileName(profile.name),
+            username: deps.normalizeAiProfileUsername(profile.username, profile.name),
+            icon: deps.normalizeAiProfileIcon(profile.icon),
+            color: deps.normalizeAiProfileColor(profile.color),
+            avatarUrl: incomingAvatarUrlProvided
+                ? normalizeAiProfileAvatarUrl(profile.avatarUrl)
+                : normalizeAiProfileAvatarUrl(existingProfile?.avatarUrl),
+            avatarSourceUrl: incomingAvatarSourceUrlProvided
+                ? normalizeAiProfileAvatarUrl(profile.avatarSourceUrl)
+                : normalizeAiProfileAvatarUrl(existingProfile?.avatarSourceUrl),
+            description: profile.description ?? null,
+            role: profile.role ?? null,
+            provider: profile.provider ?? null,
+            model: profile.model ?? null,
+            surfaceType: profile.surfaceType ?? null,
+            seatScope: profile.seatScope ?? null,
+            providerMetadata: profile.providerMetadata ?? null,
+            archivedAt: normalizedArchivedAt,
+            archivedBy: normalizedArchivedBy,
+            archivedReason: normalizedArchivedReason,
+            mergedIntoProfileId: normalizedMergedIntoProfileId,
+            rosterStateUpdatedAt: normalizedRosterStateUpdatedAt,
+            createdAt: normalizedCreatedAt,
+            updatedAt: normalizedUpdatedAt,
+            lastActiveAt: normalizedLastActiveAt
         }
-    }
+        : existingProfile;
+    const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+        name: metadataSourceProfile?.name ?? deps.normalizeAiProfileName(profile.name),
+        description: metadataSourceProfile?.description,
+        role: metadataSourceProfile?.role,
+        provider: metadataSourceProfile?.provider,
+        model: metadataSourceProfile?.model,
+        surfaceType: metadataSourceProfile?.surfaceType,
+    }, existingProfile);
+    const resolvedSeatScope = incomingMetadataWins
+        ? resolveSyncedAiProfileSeatScope(deps, profile.seatScope, existingProfile)
+        : {
+            seatScope: existingProfile?.seatScope ?? null,
+            seatScopeProvided: existingProfile?.seatScope !== undefined,
+        };
+    const mergedProfileToken = incomingMetadataWins
+        ? String(profile.profileToken || '').trim()
+        : String(existingRow?.profile_token || '').trim();
+    const mergedName = metadataSourceProfile?.name ?? deps.normalizeAiProfileName(profile.name);
+    const mergedUsername = metadataSourceProfile?.username ?? deps.normalizeAiProfileUsername(profile.username, profile.name);
+    const mergedIcon = metadataSourceProfile?.icon ?? deps.normalizeAiProfileIcon(profile.icon);
+    const mergedColor = metadataSourceProfile?.color ?? deps.normalizeAiProfileColor(profile.color);
+    const incomingAvatarFieldsWin = incomingMetadataWins || metadataComparison === 0;
+    const mergedAvatarUrl = incomingAvatarUrlProvided && incomingAvatarFieldsWin
+        ? normalizeAiProfileAvatarUrl(profile.avatarUrl)
+        : normalizeAiProfileAvatarUrl(existingProfile?.avatarUrl);
+    const mergedAvatarSourceUrl = incomingAvatarSourceUrlProvided && incomingAvatarFieldsWin
+        ? normalizeAiProfileAvatarUrl(profile.avatarSourceUrl)
+        : normalizeAiProfileAvatarUrl(existingProfile?.avatarSourceUrl);
+    const mergedProviderMetadata = incomingMetadataWins
+        ? (profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
+            ? JSON.stringify(profile.providerMetadata)
+            : null)
+        : (typeof existingRow?.provider_metadata_json === 'string' ? existingRow.provider_metadata_json : null);
+    const mergedArchivedAt = incomingLifecycleWins ? normalizedArchivedAt : existingArchivedAt;
+    const mergedArchivedBy = incomingLifecycleWins ? normalizedArchivedBy : existingArchivedBy;
+    const mergedArchivedReason = incomingLifecycleWins ? normalizedArchivedReason : existingArchivedReason;
+    const mergedMergedIntoProfileId = incomingLifecycleWins ? normalizedMergedIntoProfileId : existingMergedIntoProfileId;
+    const mergedRosterStateUpdatedAt = incomingLifecycleWins
+        ? normalizedRosterStateUpdatedAt
+        : existingRosterStateUpdatedAt;
+    const mergedCreatedAt = existingCreatedAt || normalizedCreatedAt;
+    const mergedUpdatedAt = incomingMetadataWins ? normalizedUpdatedAt : (existingUpdatedAt || normalizedUpdatedAt);
+    const mergedLastActiveAt = compareIsoStrings(normalizedLastActiveAt, existingLastActiveAt) > 0
+        ? normalizedLastActiveAt
+        : existingLastActiveAt;
     deps.db.prepare(`
         INSERT INTO ai_profiles (
             id, tenant_id, workspace_id, profile_token, name, username, icon, color,
-            description, role, provider, model, surface_type, provider_metadata_json, created_at, updated_at, last_active_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            avatar_url, avatar_source_url, description, role, provider, model, surface_type, seat_scope, provider_metadata_json,
+            archived_at, archived_by, archived_reason, merged_into_profile_id,
+            roster_state_updated_at, created_at, updated_at, last_active_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(id) DO UPDATE SET
             workspace_id = excluded.workspace_id,
             profile_token = excluded.profile_token,
@@ -102,18 +485,24 @@ export function upsertAiProfileForSyncService(deps, profile) {
             username = excluded.username,
             icon = excluded.icon,
             color = excluded.color,
+            avatar_url = excluded.avatar_url,
+            avatar_source_url = excluded.avatar_source_url,
             description = excluded.description,
             role = excluded.role,
             provider = excluded.provider,
             model = excluded.model,
             surface_type = excluded.surface_type,
+            seat_scope = excluded.seat_scope,
             provider_metadata_json = excluded.provider_metadata_json,
+            archived_at = excluded.archived_at,
+            archived_by = excluded.archived_by,
+            archived_reason = excluded.archived_reason,
+            merged_into_profile_id = excluded.merged_into_profile_id,
+            roster_state_updated_at = excluded.roster_state_updated_at,
             created_at = excluded.created_at,
             updated_at = excluded.updated_at,
             last_active_at = excluded.last_active_at
-    `).run(profileId, deps.tenantId, normalizedWorkspaceId, String(profile.profileToken || '').trim(), deps.normalizeAiProfileName(profile.name), deps.normalizeAiProfileUsername(profile.username, profile.name), deps.normalizeAiProfileIcon(profile.icon), deps.normalizeAiProfileColor(profile.color), normalizeOptionalProfileField(profile.description) ?? null, normalizeOptionalProfileField(profile.role) ?? null, normalizeOptionalProfileField(profile.provider) ?? null, normalizeOptionalProfileField(profile.model) ?? null, normalizedSurfaceType, profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
-        ? JSON.stringify(profile.providerMetadata)
-        : null, normalizedCreatedAt, normalizedUpdatedAt, normalizedLastActiveAt);
+    `).run(profileId, deps.tenantId, normalizedWorkspaceId, mergedProfileToken, mergedName, mergedUsername, mergedIcon, mergedColor, mergedAvatarUrl, mergedAvatarSourceUrl, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, resolvedMetadata.surfaceType, resolvedSeatScope.seatScope, mergedProviderMetadata, mergedArchivedAt, mergedArchivedBy, mergedArchivedReason, mergedMergedIntoProfileId, mergedRosterStateUpdatedAt, mergedCreatedAt, mergedUpdatedAt, mergedLastActiveAt);
     const refreshed = deps.db.prepare(`
         SELECT *
         FROM ai_profiles
@@ -123,7 +512,7 @@ export function upsertAiProfileForSyncService(deps, profile) {
     if (!refreshed) {
         throw deps.createRuleError('Failed to upsert AI profile during sync', 500, 'AI_PROFILE_SYNC_UPSERT_FAILED');
     }
-    return deps.aiProfileRowToRecord(refreshed);
+    return hydrateAiProfileRecord(deps, refreshed);
 }
 export function mergeAiProfilesService(deps, input) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
@@ -134,15 +523,18 @@ export function mergeAiProfilesService(deps, input) {
     if (keepId === mergeId)
         throw deps.createRuleError('keepId and mergeId must be different profiles', 400, 'MERGE_PROFILES_SAME_ID');
     const keepProfile = deps.db.prepare(`
-        SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ? AND id = ? LIMIT 1
+        SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ? AND id = ? AND archived_at IS NULL LIMIT 1
     `).get(deps.tenantId, normalizedWorkspaceId, keepId);
     if (!keepProfile)
         throw deps.createRuleError(`Profile ${keepId} not found`, 404, 'MERGE_PROFILES_KEEP_NOT_FOUND');
     const mergeProfile = deps.db.prepare(`
-        SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ? AND id = ? LIMIT 1
+        SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ? AND id = ? AND archived_at IS NULL LIMIT 1
     `).get(deps.tenantId, normalizedWorkspaceId, mergeId);
     if (!mergeProfile)
         throw deps.createRuleError(`Profile ${mergeId} not found`, 404, 'MERGE_PROFILES_MERGE_NOT_FOUND');
+    const keepRecord = deps.aiProfileRowToRecord(keepProfile);
+    const mergeRecord = deps.aiProfileRowToRecord(mergeProfile);
+    const mergedSeatScope = resolveAiProfileSeatScope(deps, mergeRecord.seatScope, keepRecord);
     const mergedAt = new Date().toISOString();
     const doMerge = deps.db.transaction(() => {
         deps.db.prepare(`
@@ -153,51 +545,330 @@ export function mergeAiProfilesService(deps, input) {
             UPDATE tasks SET created_by = ?, updated_at = ?
             WHERE tenant_id = ? AND workspace_id = ? AND created_by = ?
         `).run(keepId, mergedAt, deps.tenantId, normalizedWorkspaceId, mergeId);
+        deps.db.prepare(`
+            UPDATE ai_profiles
+            SET seat_scope = ?,
+                avatar_url = COALESCE(avatar_url, ?),
+                avatar_source_url = COALESCE(avatar_source_url, ?),
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).run(mergedSeatScope.seatScope, normalizeAiProfileAvatarUrl(mergeRecord.avatarUrl), normalizeAiProfileAvatarUrl(mergeRecord.avatarSourceUrl), mergedAt, deps.tenantId, normalizedWorkspaceId, keepId);
         deps.db.prepare(`
             UPDATE comments SET author = ?
             WHERE tenant_id = ? AND workspace_id = ? AND author = ?
         `).run(keepId, deps.tenantId, normalizedWorkspaceId, mergeId);
         deps.db.prepare(`
-            DELETE FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ? AND id = ?
-        `).run(deps.tenantId, normalizedWorkspaceId, mergeId);
+            UPDATE ai_profiles
+            SET archived_at = ?,
+                archived_by = ?,
+                archived_reason = ?,
+                merged_into_profile_id = ?,
+                roster_state_updated_at = ?,
+                updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        `).run(mergedAt, keepId, 'merged_duplicate', keepId, mergedAt, mergedAt, deps.tenantId, normalizedWorkspaceId, mergeId);
     });
     doMerge();
     const refreshed = deps.db.prepare(`
         SELECT * FROM ai_profiles WHERE tenant_id = ? AND id = ? LIMIT 1
     `).get(deps.tenantId, keepId);
-    return deps.aiProfileRowToRecord(refreshed);
+    return hydrateAiProfileRecord(deps, refreshed);
+}
+export function updateAiProfileAvatarService(deps, input) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const profileId = String(input.profileId || '').trim();
+    if (!profileId)
+        throw deps.createRuleError('profileId is required', 400, 'AI_PROFILE_ID_REQUIRED');
+    const existing = deps.db.prepare(`
+        SELECT *
+        FROM ai_profiles
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ? AND archived_at IS NULL
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, profileId);
+    if (!existing) {
+        throw deps.createRuleError(`Profile ${profileId} not found`, 404, 'AI_PROFILE_NOT_FOUND');
+    }
+    const avatarUrl = normalizeAiProfileAvatarUrl(input.avatarUrl);
+    if (typeof input.avatarUrl === 'string' && input.avatarUrl.trim().length > 0 && !avatarUrl) {
+        throw deps.createRuleError('avatarUrl must be a Taskforce context URL', 400, 'AI_PROFILE_AVATAR_URL_INVALID');
+    }
+    const avatarSourceUrl = input.avatarSourceUrl === undefined
+        ? normalizeAiProfileAvatarUrl(existing.avatar_source_url)
+        : normalizeAiProfileAvatarUrl(input.avatarSourceUrl);
+    if (typeof input.avatarSourceUrl === 'string' && input.avatarSourceUrl.trim().length > 0 && !avatarSourceUrl) {
+        throw deps.createRuleError('avatarSourceUrl must be a Taskforce context URL', 400, 'AI_PROFILE_AVATAR_SOURCE_URL_INVALID');
+    }
+    const updatedAt = new Date().toISOString();
+    deps.db.prepare(`
+        UPDATE ai_profiles
+        SET avatar_url = ?,
+            avatar_source_url = ?,
+            updated_at = ?
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+    `).run(avatarUrl, avatarSourceUrl, updatedAt, deps.tenantId, normalizedWorkspaceId, profileId);
+    const refreshed = deps.db.prepare(`
+        SELECT *
+        FROM ai_profiles
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, profileId);
+    if (!refreshed) {
+        throw deps.createRuleError('Failed to update AI profile avatar', 500, 'AI_PROFILE_AVATAR_UPDATE_FAILED');
+    }
+    return hydrateAiProfileRecord(deps, refreshed);
+}
+export function archiveAiProfileService(deps, input) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const profileId = String(input.profileId || '').trim();
+    if (!profileId)
+        throw deps.createRuleError('profileId is required', 400, 'ARCHIVE_AI_PROFILE_INVALID_INPUT');
+    const existingRow = deps.db.prepare(`
+        SELECT *
+        FROM ai_profiles
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ? AND archived_at IS NULL
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, profileId);
+    if (!existingRow) {
+        throw deps.createRuleError(`Profile ${profileId} not found`, 404, 'ARCHIVE_AI_PROFILE_NOT_FOUND');
+    }
+    const openTaskRow = deps.db.prepare(`
+        SELECT COUNT(*) AS c
+        FROM tasks
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND assignee = ?
+          AND COALESCE(is_archived, 0) = 0
+          AND LOWER(COALESCE(status, 'task')) NOT IN ('done', 'cancelled')
+    `).get(deps.tenantId, normalizedWorkspaceId, profileId);
+    const openTaskCount = Math.max(0, Number(openTaskRow?.c || 0));
+    if (openTaskCount > 0) {
+        throw deps.createRuleError('This AI profile still owns open tasks. Reassign or close them before removing it from the roster.', 409, 'AI_PROFILE_HAS_OPEN_TASKS', { workspaceId: normalizedWorkspaceId, profileId, openTaskCount });
+    }
+    const archivedAt = new Date().toISOString();
+    deps.db.prepare(`
+        UPDATE ai_profiles
+        SET archived_at = ?,
+            archived_by = ?,
+            archived_reason = ?,
+            merged_into_profile_id = NULL,
+            roster_state_updated_at = ?,
+            updated_at = ?
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+    `).run(archivedAt, normalizeNullableProfileReference(input.archivedBy), normalizeOptionalProfileField(input.reason) ?? 'manual_archive', archivedAt, archivedAt, deps.tenantId, normalizedWorkspaceId, profileId);
+    const archivedRow = deps.db.prepare(`
+        SELECT *
+        FROM ai_profiles
+        WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, profileId);
+    if (!archivedRow) {
+        throw deps.createRuleError('Failed to archive AI profile', 500, 'ARCHIVE_AI_PROFILE_FAILED');
+    }
+    return {
+        profile: hydrateAiProfileRecord(deps, archivedRow),
+        openTaskCount,
+    };
 }
-export function resolveAiProfileService(deps, input) {
+export function resolveAiProfileService(deps, input, options) {
     const normalizedWorkspaceId = deps.normalizeWorkspaceId(input.workspaceId);
     const name = deps.normalizeAiProfileName(input.name);
     const profileToken = String(input.profileToken || '').trim();
     const now = new Date().toISOString();
+    const trustedSeatScope = normalizeAiProfileSeatScopeInput(deps, options?.trustedSeatScope);
     if (profileToken) {
-        const existingRow = deps.db.prepare(`
+        const existingRows = deps.db.prepare(`
             SELECT *
             FROM ai_profiles
             WHERE tenant_id = ?
               AND workspace_id = ?
               AND profile_token = ?
-            LIMIT 1
-        `).get(deps.tenantId, normalizedWorkspaceId, profileToken);
+              AND archived_at IS NULL
+            ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
+        `).all(deps.tenantId, normalizedWorkspaceId, profileToken);
+        const existingRow = findFirstAiProfileRowForTrustedSeatScope(deps, existingRows, trustedSeatScope);
         if (!existingRow) {
-            throw deps.createRuleError('AI profile token is invalid for this workspace', 404, 'AI_PROFILE_NOT_FOUND');
+            const archivedRows = deps.db.prepare(`
+                SELECT *
+                FROM ai_profiles
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND profile_token = ?
+                  AND archived_at IS NOT NULL
+                ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
+            `).all(deps.tenantId, normalizedWorkspaceId, profileToken);
+            const archivedRow = findFirstAiProfileRowForTrustedSeatScope(deps, archivedRows, trustedSeatScope);
+            if (!archivedRow) {
+                if (existingRows.length === 0 && archivedRows.length === 0) {
+                    throw deps.createRuleError('AI profile token is invalid for this workspace', 404, 'AI_PROFILE_NOT_FOUND');
+                }
+            }
+            else {
+                const existingProfile = deps.aiProfileRowToRecord(archivedRow);
+                const nextName = name;
+                const nextUsername = deps.normalizeAiProfileUsername(undefined, nextName);
+                const nextIcon = input.icon === undefined
+                    ? existingProfile.icon
+                    : deps.normalizeAiProfileIcon(input.icon);
+                const nextColor = input.color === undefined
+                    ? existingProfile.color
+                    : deps.normalizeAiProfileColor(input.color);
+                const nextDescription = normalizeOptionalProfileField(input.description);
+                const nextRole = normalizeOptionalProfileField(input.role);
+                const nextProvider = normalizeOptionalProfileField(input.provider);
+                const nextModel = normalizeOptionalProfileField(input.model);
+                const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+                    name: nextName,
+                    description: nextDescription,
+                    role: nextRole,
+                    provider: nextProvider,
+                    model: nextModel,
+                    surfaceType: input.surfaceType,
+                }, existingProfile);
+                const resolvedSeatScope = resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, existingProfile);
+                if (requiresCloudSeatReservation(existingProfile, resolvedSeatScope.seatScope)) {
+                    assertAiProfileSeatAvailable(deps, normalizedWorkspaceId);
+                }
+                deps.db.prepare(`
+                    UPDATE ai_profiles
+                    SET name = ?,
+                        username = ?,
+                        icon = ?,
+                        color = ?,
+                        description = COALESCE(?, description),
+                        role = COALESCE(?, role),
+                        provider = COALESCE(?, provider),
+                        model = COALESCE(?, model),
+                        surface_type = CASE
+                            WHEN ? = 1 THEN ?
+                            ELSE surface_type
+                        END,
+                        seat_scope = CASE
+                            WHEN ? = 1 THEN ?
+                            ELSE seat_scope
+                        END,
+                        archived_at = NULL,
+                        archived_by = NULL,
+                        archived_reason = NULL,
+                        merged_into_profile_id = NULL,
+                        roster_state_updated_at = ?,
+                        last_active_at = ?,
+                        updated_at = ?
+                    WHERE tenant_id = ? AND id = ?
+                `).run(nextName, nextUsername, nextIcon, nextColor, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, resolvedMetadata.surfaceTypeProvided ? 1 : 0, resolvedMetadata.surfaceType, resolvedSeatScope.seatScopeProvided ? 1 : 0, resolvedSeatScope.seatScope, now, now, now, deps.tenantId, String(archivedRow.id || '').trim());
+                const refreshed = deps.db.prepare(`
+                    SELECT *
+                    FROM ai_profiles
+                    WHERE tenant_id = ? AND id = ?
+                    LIMIT 1
+                `).get(deps.tenantId, String(archivedRow.id || '').trim());
+                if (!refreshed) {
+                    throw deps.createRuleError('Failed to refresh AI profile', 500, 'AI_PROFILE_REFRESH_FAILED');
+                }
+                return {
+                    created: false,
+                    profile: hydrateAiProfileRecord(deps, refreshed)
+                };
+            }
         }
-        const existingProfile = deps.aiProfileRowToRecord(existingRow);
+        else {
+            const existingProfile = deps.aiProfileRowToRecord(existingRow);
+            const nextName = name;
+            const nextUsername = deps.normalizeAiProfileUsername(undefined, nextName);
+            const nextIcon = input.icon === undefined
+                ? existingProfile.icon
+                : deps.normalizeAiProfileIcon(input.icon);
+            const nextColor = input.color === undefined
+                ? existingProfile.color
+                : deps.normalizeAiProfileColor(input.color);
+            const nextDescription = normalizeOptionalProfileField(input.description);
+            const nextRole = normalizeOptionalProfileField(input.role);
+            const nextProvider = normalizeOptionalProfileField(input.provider);
+            const nextModel = normalizeOptionalProfileField(input.model);
+            const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+                name: nextName,
+                description: nextDescription,
+                role: nextRole,
+                provider: nextProvider,
+                model: nextModel,
+                surfaceType: input.surfaceType,
+            }, existingProfile);
+            const resolvedSeatScope = resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, existingProfile);
+            if (requiresCloudSeatReservation(existingProfile, resolvedSeatScope.seatScope)) {
+                assertAiProfileSeatAvailable(deps, normalizedWorkspaceId);
+            }
+            deps.db.prepare(`
+                UPDATE ai_profiles
+                SET name = ?,
+                    username = ?,
+                    icon = ?,
+                    color = ?,
+                    description = COALESCE(?, description),
+                    role = COALESCE(?, role),
+                    provider = COALESCE(?, provider),
+                    model = COALESCE(?, model),
+                    surface_type = CASE
+                        WHEN ? = 1 THEN ?
+                        ELSE surface_type
+                    END,
+                    seat_scope = CASE
+                        WHEN ? = 1 THEN ?
+                        ELSE seat_scope
+                    END,
+                    last_active_at = ?,
+                    updated_at = ?
+                WHERE tenant_id = ? AND id = ?
+            `).run(nextName, nextUsername, nextIcon, nextColor, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, resolvedMetadata.surfaceTypeProvided ? 1 : 0, resolvedMetadata.surfaceType, resolvedSeatScope.seatScopeProvided ? 1 : 0, resolvedSeatScope.seatScope, now, now, deps.tenantId, String(existingRow.id || '').trim());
+            const refreshed = deps.db.prepare(`
+                SELECT *
+                FROM ai_profiles
+                WHERE tenant_id = ? AND id = ?
+                LIMIT 1
+            `).get(deps.tenantId, String(existingRow.id || '').trim());
+            if (!refreshed) {
+                throw deps.createRuleError('Failed to refresh AI profile', 500, 'AI_PROFILE_REFRESH_FAILED');
+            }
+            return {
+                created: false,
+                profile: hydrateAiProfileRecord(deps, refreshed)
+            };
+        }
+    }
+    const exactMatches = deps.db.prepare(`
+        SELECT *
+        FROM ai_profiles
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND archived_at IS NULL
+          AND (
+                LOWER(name) = LOWER(?)
+                OR LOWER(username) = LOWER(?)
+          )
+        ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
+    `).all(deps.tenantId, normalizedWorkspaceId, name, deps.normalizeAiProfileUsername(undefined, name));
+    const scopedExactMatches = filterAiProfileRowsForTrustedSeatScope(deps, exactMatches, trustedSeatScope);
+    if (scopedExactMatches.length > 0) {
+        const canonicalId = String(scopedExactMatches[0].id || '').trim();
         const nextName = name;
         const nextUsername = deps.normalizeAiProfileUsername(undefined, nextName);
-        const nextIcon = input.icon === undefined
-            ? existingProfile.icon
-            : deps.normalizeAiProfileIcon(input.icon);
-        const nextColor = input.color === undefined
-            ? existingProfile.color
-            : deps.normalizeAiProfileColor(input.color);
+        const nextIcon = deps.normalizeAiProfileIcon(input.icon);
+        const nextColor = deps.normalizeAiProfileColor(input.color);
         const nextDescription = normalizeOptionalProfileField(input.description);
         const nextRole = normalizeOptionalProfileField(input.role);
         const nextProvider = normalizeOptionalProfileField(input.provider);
         const nextModel = normalizeOptionalProfileField(input.model);
-        const nextSurfaceType = normalizeAiProfileSurfaceTypeInput(deps, input.surfaceType);
+        const existingProfile = deps.aiProfileRowToRecord(scopedExactMatches[0]);
+        const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+            name: nextName,
+            description: nextDescription,
+            role: nextRole,
+            provider: nextProvider,
+            model: nextModel,
+            surfaceType: input.surfaceType,
+        }, existingProfile);
+        const resolvedSeatScope = resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, existingProfile);
+        if (requiresCloudSeatReservation(existingProfile, resolvedSeatScope.seatScope)) {
+            assertAiProfileSeatAvailable(deps, normalizedWorkspaceId);
+        }
         deps.db.prepare(`
             UPDATE ai_profiles
             SET name = ?,
@@ -208,41 +879,53 @@ export function resolveAiProfileService(deps, input) {
                 role = COALESCE(?, role),
                 provider = COALESCE(?, provider),
                 model = COALESCE(?, model),
+                last_active_at = ?,
+                updated_at = ?,
                 surface_type = CASE
                     WHEN ? = 1 THEN ?
                     ELSE surface_type
                 END,
-                last_active_at = ?,
-                updated_at = ?
+                seat_scope = CASE
+                    WHEN ? = 1 THEN ?
+                    ELSE seat_scope
+                END
             WHERE tenant_id = ? AND id = ?
-        `).run(nextName, nextUsername, nextIcon, nextColor, nextDescription ?? null, nextRole ?? null, nextProvider ?? null, nextModel ?? null, nextSurfaceType !== undefined ? 1 : 0, nextSurfaceType, now, now, deps.tenantId, String(existingRow.id || '').trim());
-        const refreshed = deps.db.prepare(`
+        `).run(nextName, nextUsername, nextIcon, nextColor, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, now, now, resolvedMetadata.surfaceTypeProvided ? 1 : 0, resolvedMetadata.surfaceType, resolvedSeatScope.seatScopeProvided ? 1 : 0, resolvedSeatScope.seatScope, deps.tenantId, canonicalId);
+        const reused = deps.db.prepare(`
             SELECT *
             FROM ai_profiles
             WHERE tenant_id = ? AND id = ?
             LIMIT 1
-        `).get(deps.tenantId, String(existingRow.id || '').trim());
-        if (!refreshed) {
+        `).get(deps.tenantId, canonicalId);
+        if (!reused) {
             throw deps.createRuleError('Failed to refresh AI profile', 500, 'AI_PROFILE_REFRESH_FAILED');
         }
         return {
             created: false,
-            profile: deps.aiProfileRowToRecord(refreshed)
+            profile: hydrateAiProfileRecord(deps, reused),
+            ...(scopedExactMatches.length > 1 ? {
+                duplicateWarning: {
+                    existingProfileId: canonicalId,
+                    message: `Multiple profiles matched "${name}". Reused ${canonicalId}; merge the remaining duplicates.`
+                }
+            } : {})
         };
     }
-    const exactMatches = deps.db.prepare(`
+    const archivedMatches = deps.db.prepare(`
         SELECT *
         FROM ai_profiles
         WHERE tenant_id = ?
           AND workspace_id = ?
+          AND archived_at IS NOT NULL
           AND (
                 LOWER(name) = LOWER(?)
                 OR LOWER(username) = LOWER(?)
           )
         ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
     `).all(deps.tenantId, normalizedWorkspaceId, name, deps.normalizeAiProfileUsername(undefined, name));
-    if (exactMatches.length > 0) {
-        const canonicalId = String(exactMatches[0].id || '').trim();
+    const scopedArchivedMatches = filterAiProfileRowsForTrustedSeatScope(deps, archivedMatches, trustedSeatScope);
+    if (scopedArchivedMatches.length > 0) {
+        const canonicalId = String(scopedArchivedMatches[0].id || '').trim();
         const nextName = name;
         const nextUsername = deps.normalizeAiProfileUsername(undefined, nextName);
         const nextIcon = deps.normalizeAiProfileIcon(input.icon);
@@ -251,7 +934,19 @@ export function resolveAiProfileService(deps, input) {
         const nextRole = normalizeOptionalProfileField(input.role);
         const nextProvider = normalizeOptionalProfileField(input.provider);
         const nextModel = normalizeOptionalProfileField(input.model);
-        const nextSurfaceType = normalizeAiProfileSurfaceTypeInput(deps, input.surfaceType);
+        const existingProfile = deps.aiProfileRowToRecord(scopedArchivedMatches[0]);
+        const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+            name: nextName,
+            description: nextDescription,
+            role: nextRole,
+            provider: nextProvider,
+            model: nextModel,
+            surfaceType: input.surfaceType,
+        }, existingProfile);
+        const resolvedSeatScope = resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, existingProfile);
+        if (requiresCloudSeatReservation(existingProfile, resolvedSeatScope.seatScope)) {
+            assertAiProfileSeatAvailable(deps, normalizedWorkspaceId);
+        }
         deps.db.prepare(`
             UPDATE ai_profiles
             SET name = ?,
@@ -264,30 +959,33 @@ export function resolveAiProfileService(deps, input) {
                 model = COALESCE(?, model),
                 last_active_at = ?,
                 updated_at = ?,
+                archived_at = NULL,
+                archived_by = NULL,
+                archived_reason = NULL,
+                merged_into_profile_id = NULL,
+                roster_state_updated_at = ?,
                 surface_type = CASE
                     WHEN ? = 1 THEN ?
                     ELSE surface_type
+                END,
+                seat_scope = CASE
+                    WHEN ? = 1 THEN ?
+                    ELSE seat_scope
                 END
             WHERE tenant_id = ? AND id = ?
-        `).run(nextName, nextUsername, nextIcon, nextColor, nextDescription ?? null, nextRole ?? null, nextProvider ?? null, nextModel ?? null, now, now, nextSurfaceType !== undefined ? 1 : 0, nextSurfaceType, deps.tenantId, canonicalId);
-        const reused = deps.db.prepare(`
+        `).run(nextName, nextUsername, nextIcon, nextColor, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, now, now, now, resolvedMetadata.surfaceTypeProvided ? 1 : 0, resolvedMetadata.surfaceType, resolvedSeatScope.seatScopeProvided ? 1 : 0, resolvedSeatScope.seatScope, deps.tenantId, canonicalId);
+        const reactivated = deps.db.prepare(`
             SELECT *
             FROM ai_profiles
             WHERE tenant_id = ? AND id = ?
             LIMIT 1
         `).get(deps.tenantId, canonicalId);
-        if (!reused) {
+        if (!reactivated) {
             throw deps.createRuleError('Failed to refresh AI profile', 500, 'AI_PROFILE_REFRESH_FAILED');
         }
         return {
             created: false,
-            profile: deps.aiProfileRowToRecord(reused),
-            ...(exactMatches.length > 1 ? {
-                duplicateWarning: {
-                    existingProfileId: canonicalId,
-                    message: `Multiple profiles matched "${name}". Reused ${canonicalId}; merge the remaining duplicates.`
-                }
-            } : {})
+            profile: hydrateAiProfileRecord(deps, reactivated)
         };
     }
     const id = deps.generateEntityId('ai-profile');
@@ -299,16 +997,29 @@ export function resolveAiProfileService(deps, input) {
     const role = normalizeOptionalProfileField(input.role);
     const provider = normalizeOptionalProfileField(input.provider);
     const model = normalizeOptionalProfileField(input.model);
-    const surfaceType = normalizeAiProfileSurfaceTypeInput(deps, input.surfaceType);
+    const resolvedMetadata = resolveAiProfileMetadataFields(deps, {
+        name,
+        description,
+        role,
+        provider,
+        model,
+        surfaceType: input.surfaceType,
+    }, null);
+    const resolvedSeatScope = resolveTrustedAiProfileSeatScope(deps, trustedSeatScope, null);
+    if (resolvedSeatScope.seatScope === 'cloud_metered') {
+        assertAiProfileSeatAvailable(deps, normalizedWorkspaceId);
+    }
     const providerMetadata = input.providerMetadata && typeof input.providerMetadata === 'object'
         ? input.providerMetadata
         : null;
     deps.db.prepare(`
         INSERT INTO ai_profiles (
             id, tenant_id, workspace_id, profile_token, name, username, icon, color,
-            description, role, provider, model, surface_type, provider_metadata_json, created_at, updated_at, last_active_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, deps.tenantId, normalizedWorkspaceId, issuedProfileToken, name, username, icon, color, description ?? null, role ?? null, provider ?? null, model ?? null, surfaceType, providerMetadata ? JSON.stringify(providerMetadata) : null, now, now, now);
+            avatar_url, avatar_source_url, description, role, provider, model, surface_type, seat_scope, provider_metadata_json,
+            archived_at, archived_by, archived_reason, merged_into_profile_id,
+            roster_state_updated_at, created_at, updated_at, last_active_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, deps.tenantId, normalizedWorkspaceId, issuedProfileToken, name, username, icon, color, null, null, resolvedMetadata.description, resolvedMetadata.role, resolvedMetadata.provider, resolvedMetadata.model, resolvedMetadata.surfaceType, resolvedSeatScope.seatScope, providerMetadata ? JSON.stringify(providerMetadata) : null, null, null, null, null, now, now, now, now);
     const created = deps.db.prepare(`
         SELECT *
         FROM ai_profiles
@@ -320,6 +1031,6 @@ export function resolveAiProfileService(deps, input) {
     }
     return {
         created: true,
-        profile: deps.aiProfileRowToRecord(created),
+        profile: hydrateAiProfileRecord(deps, created),
     };
 }