@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/core/TaskTaxonomyValidation.test.js

@@ -348,6 +348,59 @@ describe('TaskforceCore taxonomy validation', () => {
         core.close();
         fs.rmSync(projectRoot, { recursive: true, force: true });
     });
+    it('migrates legacy config-backed taxonomy data once and no longer depends on config for runtime state', () => {
+        const projectRoot = makeTempProjectRoot();
+        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
+        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            categories: [{ value: 'legacy', label: 'Legacy' }],
+            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
+            priorities: [{ value: 9, label: 'Legacy Priority', color: 'red-500', icon: 'AlertTriangle' }],
+            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy', widgetType: 'select', isSystem: false, multiSelect: false, options: [] }]
+        }, null, 2));
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const migratedState = core.getTaxonomyState('default');
+        expect((migratedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
+        expect((migratedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
+        expect((migratedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
+        expect((migratedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
+        core.close();
+        fs.writeFileSync(configPath, JSON.stringify({ checklistDropdownEnabled: true }, null, 2));
+        const reopened = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const persistedState = reopened.getTaxonomyState('default');
+        expect((persistedState.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default', 'legacy']);
+        expect((persistedState.types || []).map((type) => type.value)).toEqual(['legacy-type']);
+        expect((persistedState.priorities || []).map((priority) => priority.value)).toEqual([9]);
+        expect((persistedState.taxonomies || []).map((taxonomy) => taxonomy.id)).toEqual(['legacy-taxonomy']);
+        reopened.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('does not seed new workspaces from legacy config-backed taxonomy definitions', () => {
+        const projectRoot = makeTempProjectRoot();
+        fs.mkdirSync(path.join(projectRoot, '.taskforce'), { recursive: true });
+        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify({
+            categories: [{ value: 'legacy', label: 'Legacy' }],
+            types: [{ value: 'legacy-type', label: 'Legacy Type' }],
+            priorities: [{ value: 9, label: 'Legacy Priority' }],
+            taxonomies: [{ id: 'legacy-taxonomy', label: 'Legacy Taxonomy' }]
+        }, null, 2));
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-new', name: 'New Workspace' });
+        const state = core.getTaxonomyState('workspace-new');
+        expect((state.categories || []).map((category) => (typeof category === 'string' ? category : category.value))).toEqual(['default']);
+        expect((state.types || []).map((type) => type.value)).toEqual([
+            'task',
+            'deliverable',
+            'issue',
+            'idea',
+            'review'
+        ]);
+        expect((state.priorities || []).map((priority) => priority.value)).toEqual([1, 2, 3]);
+        expect(state.taxonomies || []).toEqual([]);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
     it('preserves existing first-class taxonomy sections when taxonomy state updates are partial', () => {
         const projectRoot = makeTempProjectRoot();
         const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });

package/dist/core/Taskforce.d.ts

@@ -3,6 +3,8 @@ import { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
 import { type SyncEventInput } from './SyncReconciliationService.js';
 import { type FirstClassTaxonomyDisplayLabels, type WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import type { TaskActor } from '../shared/taskActor.js';
+export type { TaskActor } from '../shared/taskActor.js';
 export type { WorkspaceDeletedAssetRecord, WorkspaceDeleteSummary } from './types.js';
 import type { GlobalTaskforceSettings, UserGlobalSyncSettings, WorkspaceDeleteSummary } from './types.js';
 import type { AnnotatedAttachmentAnnotation, AnnotatedAttachmentPayload, AnnotatedAttachmentSession, AnnotatedAttachmentSessionRecord } from '../annotatedAttachments/types.js';
@@ -73,16 +75,6 @@ export interface DeletedTaskRecord {
 }
 export type TaskStatus = 'task' | 'on-hold' | 'in-progress' | 'review' | 'done' | 'cancelled';
 export type TaskAssignee = string;
-export interface TaskActor {
-    id: string;
-    kind: 'human' | 'ai';
-    label: string;
-    username: string;
-    icon: string;
-    color: string;
-    isNamed: boolean;
-    meta?: Record<string, unknown>;
-}
 export interface TaskItem {
     id: string;
     referenceNumber?: number | null;
@@ -755,6 +747,9 @@ export interface TaskforceSyncCapable {
         workspaceId?: string | null;
         includeDeleted?: boolean;
     }): AnnotatedAttachmentSessionRecord[];
+    listTaskEventsForSync(input: {
+        workspaceId?: string | null;
+    }): TaskEvent[];
     upsertAiProfileForSync(profile: AiProfileRecord): AiProfileRecord;
     replaceWorkspaceUsersForSync(input: {
         workspaceId: string;
@@ -765,6 +760,7 @@ export interface TaskforceSyncCapable {
     upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
     upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
+    upsertTaskEventForSync(event: TaskEvent): TaskEvent;
     deleteDocumentReviewSessionForSync(input: {
         workspaceId?: string | null;
         sessionId: string;
@@ -847,6 +843,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private areTaskEventValuesEqual;
     private normalizeTaskEventValue;
     private buildTaskUpdateChanges;
+    private filterAutosaveTaskEventChanges;
     private normalizeTaxonomyToken;
     private normalizeStatusValue;
     private sanitizeAssignee;
@@ -893,16 +890,18 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         effectiveAt?: string | null;
         effectiveUntil?: string | null;
         billingMirrorPlanId?: string | null;
-        source: 'registration' | 'checkout-start' | 'checkout-confirm' | 'stripe-webhook' | 'backfill' | 'legacy-plan-mode' | 'admin' | 'system';
+        source: 'registration' | 'invite-accept' | 'checkout-start' | 'checkout-confirm' | 'stripe-webhook' | 'backfill' | 'legacy-plan-mode' | 'admin' | 'system';
         updatedBy: string;
         createdAt?: string | null;
         updatedAt?: string | null;
     }): import("./types.js").AccountEntitlementSnapshot;
     private resolveWorkspaceLimitForUser;
     private resolveRegistrationOnboardingOutcome;
+    private ensureDefaultOnboardingEntitlement;
     createUserBillingRecord(userId: string, options?: {
         entitlementState?: string;
         planId?: string | null;
+        effectiveUntil?: string | null;
     }): void;
     getUserEntitlement(userId: string): {
         entitlementState: string;
@@ -912,6 +911,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     getAccountAccessStatus(accountId: string): import("./types.js").AccountAccessStatus;
     getEffectivePlanVersion(accountId: string): import("./types.js").PlanVersionSnapshot;
     getAccountEntitlement(accountId: string): import("./types.js").AccountEntitlementSnapshot;
+    countAiProfileUsage(workspaceId: string): import("./types.js").SeatUsageSnapshot;
     countWorkspaceSeatUsage(workspaceId: string, options?: {
         includeInvited?: boolean;
     }): import("./types.js").SeatUsageSnapshot;
@@ -969,6 +969,8 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     private resolveDefaultTypeValue;
     private getLegacyTaxonomiesConfig;
     private getLegacyPrioritiesConfig;
+    private readLegacyWorkspaceTaxonomyStateFromConfig;
+    private migrateLegacyWorkspaceTaxonomyStateIfNeeded;
     private buildEmergencyWorkspaceTaxonomyState;
     private getConfiguredDefaultStarterTaxonomyPackId;
     private getResolvedStarterWorkspaceTaxonomyState;
@@ -1268,6 +1270,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     upsertDocumentReviewSessionForSync(session: DocumentReviewSessionRecord): DocumentReviewSessionRecord;
     upsertDocumentReviewCommentForSync(comment: DocumentReviewCommentSyncRecord): DocumentReviewCommentSyncRecord;
     upsertAnnotatedAttachmentSessionForSync(session: AnnotatedAttachmentSessionRecord): AnnotatedAttachmentSessionRecord;
+    upsertTaskEventForSync(event: TaskEvent): TaskEvent;
     deleteDocumentReviewSessionForSync(input: {
         workspaceId?: string | null;
         sessionId: string;
@@ -1668,6 +1671,9 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
     updateWorkspaceUserRole(userId: string, workspaceId: string, role: AccessRole): boolean;
     getTask(id: string, workspaceId?: string): TaskItem | null;
     listTaskEvents(taskId: string, workspaceId?: string): TaskEvent[];
+    listTaskEventsForSync(input: {
+        workspaceId?: string | null;
+    }): TaskEvent[];
     getScheduleBoard(weekKey: string, showWeekends?: boolean, workspaceId?: string): ScheduleBoardResult;
     updateTaskSchedule(id: string, input: {
         scheduledDate: string | null;
@@ -1699,6 +1705,7 @@ export declare class TaskforceCore implements TaskforceSyncCapable {
         syncUpdatedAt?: string;
         actorRef?: string;
         skipTaskEvents?: boolean;
+        saveSource?: 'manual' | 'autosave';
     }): TaskItem | null;
     addComment(id: string, text: string, author: string, workspaceId?: string, options?: {
         persistBackup?: boolean;

package/dist/core/Taskforce.js

@@ -9,7 +9,7 @@ import { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
 import { AuthTokenService } from './AuthTokenService.js';
 import { getAiProfileByTokenService, listAiProfilesService, mergeAiProfilesService, resolveAiProfileService, upsertAiProfileForSyncService, } from './AiProfileService.js';
 import { syncCanonicalTaskAttachmentLinksService, } from './AttachmentLinkService.js';
-import { addTaskEventService, buildTaskActivityService, listTaskEventsInternalService, replaceTaskCommentsService, replaceTaskEventsService, } from './TaskActivityService.js';
+import { addTaskEventService, buildTaskActivityService, listTaskEventsInternalService, listWorkspaceTaskEventsService, replaceTaskCommentsService, replaceTaskEventsService, upsertTaskEventForSyncService, } from './TaskActivityService.js';
 import { addDeletedTaskRecordService, getDeletedTaskService, listDeletedTasksService, mapDeletedTaskRowService, normalizeTaskSnapshotForRestoreService, pruneDeletedTasksService, purgeExpiredDeletedTasksService, } from './DeletedTaskLifecycleService.js';
 import { applyWorkspaceSyncSnapshotService, deleteDocumentWatermarkService, getDocumentWatermarkService, listTasksForSyncService, listWorkspaceSyncDeletesSinceService, readPushIdempotencyService, recordSyncEventService, upsertDocumentWatermarkService, writePushIdempotencyService, } from './SyncReconciliationService.js';
 import { getGlobalSettingsService, hasPersistedGlobalSettingsService, readGlobalConfigService, updateGlobalSettingsService, writeGlobalConfigService, } from './GlobalSettingsService.js';
@@ -79,7 +79,7 @@ const DEFAULT_PLAN_FEATURE_CATALOG = [
         featureKey: DOCUMENT_CLOUD_STORAGE_FEATURE_KEY,
         label: 'Document Cloud Storage',
         description: 'Allow cloud document storage with an optional storage allowance in MB.',
-        allowedAccessModes: ['enabled', 'disabled'],
+        allowedAccessModes: ['enabled', 'limited', 'disabled'],
         configTemplate: {
             [DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY]: 1024
         }
@@ -666,6 +666,9 @@ export class TaskforceCore {
         }
         return changes;
     }
+    filterAutosaveTaskEventChanges(changes) {
+        return Object.fromEntries(Object.entries(changes).filter(([field]) => field !== 'title' && field !== 'description'));
+    }
     normalizeTaxonomyToken(value) {
         return String(value || '')
             .trim()
@@ -1217,6 +1220,29 @@ export class TaskforceCore {
     resolveRegistrationOnboardingOutcome(selectedPlanVersionIdRaw) {
         return this.planEntitlementService.resolveRegistrationOnboardingOutcome(selectedPlanVersionIdRaw);
     }
+    ensureDefaultOnboardingEntitlement(accountIdRaw, options) {
+        const accountId = String(accountIdRaw || '').trim();
+        if (!accountId) {
+            throw new TaskforceRuleError('accountId is required', 400, 'ACCOUNT_ID_REQUIRED');
+        }
+        if (this.hasAccountEntitlement(accountId)) {
+            return this.getAccountEntitlement(accountId);
+        }
+        const now = options?.now || new Date().toISOString();
+        const onboardingOutcome = this.resolveRegistrationOnboardingOutcome();
+        this.transitionCanonicalCommercialState({
+            accountId,
+            planVersionId: onboardingOutcome.planVersionId,
+            state: onboardingOutcome.commercialState,
+            effectiveAt: now,
+            billingMirrorPlanId: onboardingOutcome.planId,
+            source: options?.source || 'registration',
+            updatedBy: options?.updatedBy || 'registration',
+            createdAt: now,
+            updatedAt: now
+        });
+        return this.getAccountEntitlement(accountId);
+    }
     createUserBillingRecord(userId, options) {
         return this.planEntitlementService.createUserBillingRecord(userId, options);
     }
@@ -1235,6 +1261,9 @@ export class TaskforceCore {
     getAccountEntitlement(accountId) {
         return this.planEntitlementService.getAccountEntitlement(accountId);
     }
+    countAiProfileUsage(workspaceId) {
+        return this.planEntitlementService.countAiProfileUsage(workspaceId);
+    }
     countWorkspaceSeatUsage(workspaceId, options = {}) {
         return this.planEntitlementService.countWorkspaceSeatUsage(workspaceId, options);
     }
@@ -2388,6 +2417,42 @@ export class TaskforceCore {
         }
         return [];
     }
+    readLegacyWorkspaceTaxonomyStateFromConfig() {
+        const legacyCategories = this.getLegacyCategoriesConfig();
+        const legacyTypes = this.getLegacyTypesConfig();
+        const legacyPriorities = this.getLegacyPrioritiesConfig();
+        const legacyTaxonomies = this.getLegacyTaxonomiesConfig();
+        if (legacyCategories.length === 0
+            && legacyTypes.length === 0
+            && legacyPriorities.length === 0
+            && legacyTaxonomies.length === 0) {
+            return null;
+        }
+        return normalizeWorkspaceTaxonomyStatePayload({
+            categories: legacyCategories,
+            types: legacyTypes,
+            priorities: legacyPriorities,
+            taxonomies: legacyTaxonomies
+        });
+    }
+    migrateLegacyWorkspaceTaxonomyStateIfNeeded(workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        if (normalizedWorkspaceId !== 'default') {
+            return null;
+        }
+        const stored = this.readStoredWorkspaceTaxonomyState(normalizedWorkspaceId);
+        if (Object.keys(stored.state).length > 0) {
+            return stored;
+        }
+        const legacyState = this.readLegacyWorkspaceTaxonomyStateFromConfig();
+        if (!legacyState)
+            return null;
+        const persisted = this.writeWorkspaceTaxonomyState(legacyState, normalizedWorkspaceId);
+        return {
+            state: persisted.state,
+            updatedAt: persisted.updatedAt
+        };
+    }
     buildEmergencyWorkspaceTaxonomyState() {
         const emergencyPack = getEmergencyStarterTaxonomyLibraryPack();
         return {
@@ -2428,17 +2493,13 @@ export class TaskforceCore {
     }
     getEffectiveWorkspaceTaxonomyState(workspaceId) {
         const { state } = this.readStoredWorkspaceTaxonomyState(workspaceId);
-        const legacyCategories = this.getLegacyCategoriesConfig();
-        const legacyTypes = this.getLegacyTypesConfig();
-        const legacyPriorities = this.getLegacyPrioritiesConfig();
-        const legacyTaxonomies = this.getLegacyTaxonomiesConfig();
         const starterState = this.getResolvedStarterWorkspaceTaxonomyState();
         const emergencyState = this.buildEmergencyWorkspaceTaxonomyState();
         return normalizeWorkspaceTaxonomyStatePayload({
-            categories: state.categories || (legacyCategories.length > 0 ? legacyCategories : starterState.categories) || emergencyState.categories,
-            types: state.types || (legacyTypes.length > 0 ? legacyTypes : starterState.types) || emergencyState.types,
-            priorities: state.priorities || (legacyPriorities.length > 0 ? legacyPriorities : starterState.priorities) || emergencyState.priorities,
-            taxonomies: state.taxonomies || (legacyTaxonomies.length > 0 ? legacyTaxonomies : starterState.taxonomies) || emergencyState.taxonomies
+            categories: state.categories || starterState.categories || emergencyState.categories,
+            types: state.types || starterState.types || emergencyState.types,
+            priorities: state.priorities || starterState.priorities || emergencyState.priorities,
+            taxonomies: state.taxonomies || starterState.taxonomies || emergencyState.taxonomies
         });
     }
     ensureWorkspaceTaxonomyStateSeeded(workspaceId) {
@@ -2447,6 +2508,10 @@ export class TaskforceCore {
         if (Object.keys(stored.state).length > 0) {
             return stored;
         }
+        const migratedLegacy = this.migrateLegacyWorkspaceTaxonomyStateIfNeeded(normalizedWorkspaceId);
+        if (migratedLegacy) {
+            return migratedLegacy;
+        }
         const seededState = this.getEffectiveWorkspaceTaxonomyState(normalizedWorkspaceId);
         const persisted = this.writeWorkspaceTaxonomyState(seededState, normalizedWorkspaceId);
         return {
@@ -4841,6 +4906,9 @@ export class TaskforceCore {
             deletedAt: session.deletedAt,
         });
     }
+    upsertTaskEventForSync(event) {
+        return upsertTaskEventForSyncService(this.getTaskActivityServiceDeps(), event);
+    }
     deleteDocumentReviewSessionForSync(input) {
         const deps = this.getDocumentReviewServiceDeps();
         return deps.sessionStore.softDelete(input.sessionId, deps.normalizeWorkspaceId(input.workspaceId), input.deletedAt || undefined);
@@ -4883,7 +4951,8 @@ export class TaskforceCore {
             aiProfileRowToRecord: (row) => this.aiProfileRowToRecord(row),
             generateEntityId: (prefix) => this.generateEntityId(prefix),
             issueProfileToken: () => `tfp_${randomBytes(24).toString('hex')}`,
-            createRuleError: (message, statusCode = 400, code = 'TASK_RULE_VIOLATION') => new TaskforceRuleError(message, statusCode, code),
+            countAiProfileUsage: (workspaceId) => this.countAiProfileUsage(workspaceId),
+            createRuleError: (message, statusCode = 400, code = 'TASK_RULE_VIOLATION', details) => new TaskforceRuleError(message, statusCode, code, details),
         };
     }
     resolveWorkspaceActor(workspaceId, actorRef) {
@@ -5795,6 +5864,11 @@ export class TaskforceCore {
                 updated_at = ?
             WHERE tenant_id = ? AND id = ?
         `).run(hashPassword(password), 'password', user.email, now, now, this.tenantId, consumed.userId);
+        this.ensureDefaultOnboardingEntitlement(consumed.userId, {
+            source: 'invite-accept',
+            updatedBy: 'invite-accept',
+            now
+        });
         return this.completeInviteWorkspaceActivation({
             userId: consumed.userId,
             workspaceId: inviteWorkspaceId
@@ -5953,6 +6027,10 @@ export class TaskforceCore {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         return this.listTaskEventsInternal(taskId, normalizedWorkspaceId);
     }
+    listTaskEventsForSync(input) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(input.workspaceId || undefined);
+        return listWorkspaceTaskEventsService(this.getTaskActivityServiceDeps(), normalizedWorkspaceId);
+    }
     getScheduleBoard(weekKey, showWeekends = false, workspaceId) {
         const parsedWeek = this.parseIsoWeekKeyToDates(weekKey);
         if (!parsedWeek) {
@@ -6510,7 +6588,10 @@ export class TaskforceCore {
             if (!nextTask)
                 return null;
             if (options?.skipTaskEvents !== true) {
-                const changes = this.buildTaskUpdateChanges(existing, nextTask, patch);
+                const rawChanges = this.buildTaskUpdateChanges(existing, nextTask, patch);
+                const changes = options?.saveSource === 'autosave'
+                    ? this.filterAutosaveTaskEventChanges(rawChanges)
+                    : rawChanges;
                 if (Object.keys(changes).length > 0) {
                     let action = 'task-updated';
                     if (changes.status) {

package/dist/core/WorkspacePlanMode.test.js

@@ -20,19 +20,30 @@ function openCore(projectRoot) {
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `).run('default', planVersionId, 'month', `free:${planVersionId}:month`, 'free', 1, 0, null, now, now);
     };
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter' });
-    addFreeMapping('starter-v1');
-    core.upsertPlanCatalog({ planId: 'starter', displayName: 'Starter', status: 'active' });
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab' });
-    addFreeMapping('collab-v1');
-    core.upsertPlanCatalog({ planId: 'collab', displayName: 'Collab', status: 'active' });
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free' });
+    addFreeMapping('free-v1');
+    core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
     core.updatePlanVersion({
-        planId: 'collab',
+        planId: 'free',
+        versionNumber: 1,
+        seatLimit: 1
+    });
+    core.updatePlanVersionFeatures({
+        planVersionId: 'free-v1',
+        features: [
+            { featureKey: 'workspace.switching', access: 'enabled' }
+        ]
+    });
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5' });
+    addFreeMapping('team-5-v1');
+    core.upsertPlanCatalog({ planId: 'team-5', displayName: 'Team 5', status: 'active' });
+    core.updatePlanVersion({
+        planId: 'team-5',
         versionNumber: 1,
         seatLimit: 5
     });
     core.updatePlanVersionFeatures({
-        planVersionId: 'collab-v1',
+        planVersionId: 'team-5-v1',
         features: [
             { featureKey: 'collaboration.invites', access: 'enabled' },
             { featureKey: 'collaboration.team_management', access: 'enabled' }
@@ -214,4 +225,58 @@ describe('TaskforceCore account-level plan mode and invite revoke', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('grants the default onboarding entitlement to newly accepted invited accounts', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.updateGlobalSettings({
+                billing: {
+                    onboardingPolicy: {
+                        mode: 'auto_grant_free',
+                        planVersionId: 'free-v1'
+                    }
+                }
+            });
+            core.createWorkspace({ workspaceId: 'workspace-invite', name: 'Invite Workspace' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-user',
+                workspaceId: 'workspace-invite',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.setUserAccountPlanMode('owner-user', 'team');
+            core.ensureBootstrapUserAccess({
+                userId: 'invited-user',
+                workspaceId: 'workspace-invite',
+                role: 'member',
+                email: 'invited@example.com'
+            });
+            core.setWorkspaceUserDisabled('invited-user', 'workspace-invite', true);
+            const db = core.db;
+            db.prepare(`
+                UPDATE workspace_memberships
+                SET status = 'invited'
+                WHERE tenant_id = ? AND user_id = ? AND workspace_id = ?
+            `).run('default', 'invited-user', 'workspace-invite');
+            const invite = core.requestInviteAcceptance({ userId: 'invited-user', workspaceId: 'workspace-invite' });
+            const accepted = core.acceptInviteWithToken({
+                token: String(invite.token),
+                password: 'Password123!'
+            });
+            expect(accepted.workspaceId).toBe('workspace-invite');
+            expect(core.hasAccountEntitlement('invited-user')).toBe(true);
+            expect(core.getAccountEntitlement('invited-user')).toEqual(expect.objectContaining({
+                planVersionId: 'free-v1',
+                state: 'active'
+            }));
+            expect(core.getAccountAccessStatus('invited-user')).toEqual(expect.objectContaining({
+                gate: 'ok',
+                canAccessApp: true
+            }));
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
 });

package/dist/core/shared.d.ts

@@ -17,8 +17,10 @@
 import type { McpAccessTokenScope, PlanFeatureCatalogItem } from './types.js';
 export declare const DOCUMENT_CLOUD_STORAGE_FEATURE_KEY = "context.uploads";
 export declare const WORKSPACES_FEATURE_KEY = "workspace.switching";
+export declare const AI_PROFILES_FEATURE_KEY = "collaboration.ai_profiles";
 export declare const DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY = "storageLimitMb";
 export declare const WORKSPACES_LIMIT_CONFIG_KEY = "maxWorkspaces";
+export declare const AI_PROFILES_LIMIT_CONFIG_KEY = "maxAiProfiles";
 export declare const MCP_ACCESS_TOKEN_MAX_ACTIVE_PER_USER_WORKSPACE = 10;
 export declare const MCP_ACCESS_TOKEN_DEFAULT_PAGE_SIZE = 20;
 export declare const MCP_ACCESS_TOKEN_MAX_PAGE_SIZE = 100;

package/dist/core/shared.js

@@ -18,8 +18,10 @@ import { createHash, pbkdf2Sync, randomBytes, timingSafeEqual } from 'crypto';
 // === SECTION: Constants ===
 export const DOCUMENT_CLOUD_STORAGE_FEATURE_KEY = 'context.uploads';
 export const WORKSPACES_FEATURE_KEY = 'workspace.switching';
+export const AI_PROFILES_FEATURE_KEY = 'collaboration.ai_profiles';
 export const DOCUMENT_CLOUD_STORAGE_LIMIT_CONFIG_KEY = 'storageLimitMb';
 export const WORKSPACES_LIMIT_CONFIG_KEY = 'maxWorkspaces';
+export const AI_PROFILES_LIMIT_CONFIG_KEY = 'maxAiProfiles';
 export const MCP_ACCESS_TOKEN_MAX_ACTIVE_PER_USER_WORKSPACE = 10;
 export const MCP_ACCESS_TOKEN_DEFAULT_PAGE_SIZE = 20;
 export const MCP_ACCESS_TOKEN_MAX_PAGE_SIZE = 100;
@@ -50,6 +52,15 @@ export const DEFAULT_PLAN_FEATURE_CATALOG = [
         configTemplate: {
             [WORKSPACES_LIMIT_CONFIG_KEY]: 1
         }
+    },
+    {
+        featureKey: AI_PROFILES_FEATURE_KEY,
+        label: 'AI Profiles',
+        description: 'Allow registered AI collaborator profiles with an optional per-workspace limit.',
+        allowedAccessModes: ['enabled', 'limited', 'disabled'],
+        configTemplate: {
+            [AI_PROFILES_LIMIT_CONFIG_KEY]: 1
+        }
     }
 ];
 export const PLAN_FEATURE_DEPENDENCIES = Object.freeze(DEFAULT_PLAN_FEATURE_CATALOG.reduce((acc, feature) => {

package/dist/documentReviews/service.d.ts

@@ -1,4 +1,4 @@
-import type { TaskActor } from '../core/Taskforce.js';
+import type { TaskActor } from '../shared/taskActor.js';
 import type { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
 import { DocumentReviewCommentStore } from './DocumentReviewCommentStore.js';
 import { DocumentReviewSessionStore } from './DocumentReviewSessionStore.js';

package/dist/documentReviews/types.d.ts

@@ -1,4 +1,4 @@
-import type { TaskActor } from '../core/Taskforce.js';
+import type { TaskActor } from '../shared/taskActor.js';
 export type DocumentReviewSessionStatus = 'open' | 'resolved';
 export type DocumentReviewAnchorKind = 'document' | 'quote' | 'line-range';
 export interface DocumentReviewDocumentAnchor {

package/dist/hooks/auth/useTaskforceAuthBootstrap.d.ts

@@ -0,0 +1,48 @@
+import { type MutableRefObject } from 'react';
+import { createDefaultAssigneeOptions } from '../../utils/assignees';
+export type BootstrapPhase = 'idle' | 'auth' | 'workspace' | 'config' | 'ready' | 'stalled';
+interface UseTaskforceAuthBootstrapArgs {
+    runtimeConfigReady: boolean;
+    shouldProbeCloudAuth: boolean;
+    authSessionResolved: boolean;
+    resolveCloudAuthUrl: (path: string) => string;
+    authOnlyCloudMode: boolean;
+    authRequiredError: string;
+    runtimeMode: 'local' | 'cloud';
+    workspaceSelectionScope: string;
+    markBootstrapPhase: (phase: Exclude<BootstrapPhase, 'stalled'>) => void;
+    markBootstrapStalled: (message: string) => void;
+    setRuntimeMode: (mode: 'local' | 'cloud') => void;
+    setAuthRequiredForApi: (value: boolean) => void;
+    setIsAuthenticated: (value: boolean) => void;
+    setAuthUserId: (value: string) => void;
+    setAuthWorkspaceId: (value: string) => void;
+    setAuthUserEmail: (value: string) => void;
+    setAuthUserDisplayName: (value: string) => void;
+    setAuthUserAvatarUrl: (value: string) => void;
+    setUserGlobalSyncStatus: (value: 'idle' | 'disconnected') => void;
+    setUserGlobalSyncError: (value: string | null) => void;
+    setHasBetaAccess: (value: boolean) => void;
+    setAvailableWorkspaces: (value: any[]) => void;
+    setHydratedWorkspaceRole: (value: any) => void;
+    setAssigneeOptions: (value: ReturnType<typeof createDefaultAssigneeOptions>) => void;
+    setAuthBlocked: (value: boolean) => void;
+    setAuthSessionResolved: (value: boolean) => void;
+    setError: (value: string | ((prev: string) => string)) => void;
+    applyResolvedWorkspaceId: (workspaceId: string, options?: {
+        preserveNonDefaultDefault?: boolean;
+    }) => void;
+    readPersistedWorkspaceId: (scope: string) => string;
+    authSessionRequestRef: MutableRefObject<Promise<boolean> | null>;
+    authSessionEpochRef: MutableRefObject<number>;
+    authSessionLastCheckedAtRef: MutableRefObject<number>;
+    authSessionLastResultRef: MutableRefObject<boolean>;
+    isLoopbackHost: boolean;
+    setAuthStateReadyRefs: (authenticated: boolean, authSessionResolved: boolean, authRequiredForApi: boolean) => void;
+}
+export declare function useTaskforceAuthBootstrap({ runtimeConfigReady, shouldProbeCloudAuth, authSessionResolved, resolveCloudAuthUrl, authOnlyCloudMode, authRequiredError, runtimeMode, workspaceSelectionScope, markBootstrapPhase, markBootstrapStalled, setRuntimeMode, setAuthRequiredForApi, setIsAuthenticated, setAuthUserId, setAuthWorkspaceId, setAuthUserEmail, setAuthUserDisplayName, setAuthUserAvatarUrl, setUserGlobalSyncStatus, setUserGlobalSyncError, setHasBetaAccess, setAvailableWorkspaces, setHydratedWorkspaceRole, setAssigneeOptions, setAuthBlocked, setAuthSessionResolved, setError, applyResolvedWorkspaceId, readPersistedWorkspaceId, authSessionRequestRef, authSessionEpochRef, authSessionLastCheckedAtRef, authSessionLastResultRef, isLoopbackHost, setAuthStateReadyRefs }: UseTaskforceAuthBootstrapArgs): {
+    checkAuthSession: (options?: {
+        force?: boolean;
+    }) => Promise<boolean>;
+};
+export {};