@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/core/EntitlementsPolicy.test.js

@@ -7,10 +7,40 @@ function makeProjectRoot() {
     return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-entitlements-'));
 }
 function openCore(projectRoot) {
-    return new TaskforceCore({
+    const core = new TaskforceCore({
         projectRoot,
         storagePath: path.join(projectRoot, '.taskforce')
     });
+    const db = core.db;
+    const now = new Date().toISOString();
+    const addFreeMapping = (planVersionId) => {
+        db.prepare(`
+            INSERT OR IGNORE INTO billing_price_mappings (
+                tenant_id, plan_version_id, billing_interval, stripe_price_id, pricing_type, active, unit_amount, currency, created_at, updated_at
+            ) 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.createPlanVersion({
+        planId: 'collab',
+        versionNumber: 2,
+        isDefault: true,
+        seatLimit: 5
+    });
+    core.updatePlanVersionFeatures({
+        planVersionId: 'collab-v2',
+        features: [
+            { featureKey: 'collaboration.invites', access: 'enabled' },
+            { featureKey: 'collaboration.team_management', access: 'enabled' },
+            { featureKey: 'workspace.switching', access: 'enabled' }
+        ]
+    });
+    return core;
 }
 describe('Taskforce entitlements policy engine', () => {
     it('counts active + invited + disabled seats and removal frees a seat', () => {
@@ -74,6 +104,7 @@ describe('Taskforce entitlements policy engine', () => {
             core.updateAccountEntitlement({
                 accountId: 'owner-u1',
                 entitlementState: 'suspended',
+                reason: 'billing hold',
                 actorUserId: 'system-admin',
                 actorRole: 'system_admin'
             });
@@ -84,6 +115,12 @@ describe('Taskforce entitlements policy engine', () => {
             });
             expect(evaluation.allowed).toBe(false);
             expect(evaluation.reasonCode).toBe('ENTITLEMENT_STATE_BLOCKED');
+            expect(core.getAccountAccessStatus('owner-u1')).toEqual(expect.objectContaining({
+                gate: 'missing_entitlement',
+                canAccessApp: false,
+                canAccessPlans: true,
+                hasEntitlement: true
+            }));
         }
         finally {
             core.close();
@@ -102,13 +139,13 @@ describe('Taskforce entitlements policy engine', () => {
                 email: 'owner@example.com'
             });
             core.createPlanVersion({
-                planId: 'team',
-                versionNumber: 2,
+                planId: 'collab',
+                versionNumber: 3,
                 isDefault: false,
                 seatLimit: 2
             });
             core.updatePlanVersionFeatures({
-                planVersionId: 'team-v2',
+                planVersionId: 'collab-v3',
                 features: [
                     { featureKey: 'collaboration.invites', access: 'enabled' },
                     { featureKey: 'collaboration.team_management', access: 'enabled' },
@@ -117,7 +154,7 @@ describe('Taskforce entitlements policy engine', () => {
             });
             core.updateAccountEntitlement({
                 accountId: 'owner-u1',
-                planVersionId: 'team-v2',
+                planVersionId: 'collab-v3',
                 entitlementState: 'active',
                 actorUserId: 'system-admin',
                 actorRole: 'system_admin'
@@ -142,4 +179,40 @@ describe('Taskforce entitlements policy engine', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('enforces workspace limits from the workspaces feature config', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.updatePlanVersionFeatures({
+                planVersionId: 'starter-v1',
+                features: [
+                    { featureKey: 'workspace.switching', access: 'limited', config: { maxWorkspaces: 1 } }
+                ]
+            });
+            core.createWorkspace({ workspaceId: 'workspace-one', name: 'Workspace One' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-one',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                planVersionId: 'starter-v1',
+                entitlementState: 'active',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            expect(() => {
+                core.createWorkspaceForUser({
+                    userId: 'owner-u1',
+                    name: 'Workspace Two'
+                });
+            }).toThrowError(TaskforceRuleError);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
 });

package/dist/core/GlobalSettingsService.d.ts

@@ -0,0 +1,16 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+import type { GlobalTaskforceSettings } from './types.js';
+export interface GlobalSettingsServiceDeps {
+    tenantId: string;
+    runtimeMode: 'local' | 'cloud';
+    getGlobalSettingsStore: () => DatabaseAdapter;
+    ensureGlobalSettingsTable: (store: DatabaseAdapter) => void;
+    ensureStructuredSettingsTables: (store: DatabaseAdapter) => void;
+    readSettingsPayloadRow: (store: DatabaseAdapter, tableName: 'system_settings' | 'workspace_settings' | 'user_preferences' | 'global_settings', whereValues: unknown[]) => Record<string, unknown>;
+    writeSettingsPayloadRow: (store: DatabaseAdapter, tableName: 'system_settings' | 'workspace_settings' | 'user_preferences', keyValues: unknown[], payload: Record<string, unknown>, updatedAt: string) => void;
+}
+export declare function hasPersistedGlobalSettingsService(deps: GlobalSettingsServiceDeps): boolean;
+export declare function readGlobalConfigService(deps: GlobalSettingsServiceDeps): GlobalTaskforceSettings;
+export declare function writeGlobalConfigService(deps: GlobalSettingsServiceDeps, config: GlobalTaskforceSettings): void;
+export declare function getGlobalSettingsService(deps: GlobalSettingsServiceDeps): GlobalTaskforceSettings;
+export declare function updateGlobalSettingsService(deps: GlobalSettingsServiceDeps, settings: GlobalTaskforceSettings): void;

package/dist/core/GlobalSettingsService.js

@@ -0,0 +1,370 @@
+import { normalizeTaskforceTheme } from '../utils/theme.js';
+function splitGlobalSettingsPayload(settings) {
+    const system = {};
+    const userPreferences = {};
+    if (settings.email && typeof settings.email === 'object') {
+        system.email = { ...settings.email };
+    }
+    if (settings.auth && typeof settings.auth === 'object') {
+        system.auth = { ...settings.auth };
+    }
+    if (settings.site && typeof settings.site === 'object') {
+        system.site = { ...settings.site };
+    }
+    if (settings.setup && typeof settings.setup === 'object') {
+        system.setup = { ...settings.setup };
+    }
+    const normalizedTheme = normalizeTaskforceTheme(settings.theme);
+    if (normalizedTheme) {
+        userPreferences.theme = normalizedTheme;
+    }
+    if (typeof settings.shortcut === 'string' && settings.shortcut.trim().length > 0) {
+        userPreferences.shortcut = settings.shortcut.trim();
+    }
+    if (typeof settings.jsonBackupEnabled === 'boolean') {
+        userPreferences.jsonBackupEnabled = settings.jsonBackupEnabled;
+    }
+    if (typeof settings.realtimeSyncEnabled === 'boolean') {
+        userPreferences.realtimeSyncEnabled = settings.realtimeSyncEnabled;
+    }
+    if (settings.schedulePreferences && typeof settings.schedulePreferences === 'object') {
+        userPreferences.schedulePreferences = { ...settings.schedulePreferences };
+    }
+    return { system, userPreferences };
+}
+export function hasPersistedGlobalSettingsService(deps) {
+    try {
+        const store = deps.getGlobalSettingsStore();
+        deps.ensureGlobalSettingsTable(store);
+        deps.ensureStructuredSettingsTables(store);
+        const structuredRow = store.prepare(`
+            SELECT 1 as ok
+            FROM system_settings
+            WHERE tenant_id = ? AND settings_key = 'global'
+            LIMIT 1
+        `).get(deps.tenantId);
+        if (structuredRow?.ok === 1)
+            return true;
+        const userPreferencesRow = store.prepare(`
+            SELECT 1 as ok
+            FROM user_preferences
+            WHERE tenant_id = ? AND user_id = 'default' AND prefs_key = 'global'
+            LIMIT 1
+        `).get(deps.tenantId);
+        if (userPreferencesRow?.ok === 1)
+            return true;
+        const row = store.prepare('SELECT 1 as ok FROM global_settings WHERE tenant_id = ? LIMIT 1').get(deps.tenantId);
+        return Boolean(row?.ok === 1);
+    }
+    catch {
+        return false;
+    }
+}
+export function readGlobalConfigService(deps) {
+    const store = deps.getGlobalSettingsStore();
+    deps.ensureGlobalSettingsTable(store);
+    deps.ensureStructuredSettingsTables(store);
+    try {
+        const systemSettings = deps.readSettingsPayloadRow(store, 'system_settings', [deps.tenantId, 'global']);
+        const userPreferences = deps.readSettingsPayloadRow(store, 'user_preferences', [deps.tenantId, 'default', 'global']);
+        if (Object.keys(systemSettings).length > 0 || Object.keys(userPreferences).length > 0) {
+            return {
+                ...systemSettings,
+                ...userPreferences
+            };
+        }
+        const legacy = deps.readSettingsPayloadRow(store, 'global_settings', [deps.tenantId]);
+        if (Object.keys(legacy).length > 0) {
+            const migrated = legacy;
+            writeGlobalConfigService(deps, migrated);
+            return migrated;
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+export function writeGlobalConfigService(deps, config) {
+    const now = new Date().toISOString();
+    const store = deps.getGlobalSettingsStore();
+    deps.ensureGlobalSettingsTable(store);
+    deps.ensureStructuredSettingsTables(store);
+    const split = splitGlobalSettingsPayload(config);
+    deps.writeSettingsPayloadRow(store, 'system_settings', [deps.tenantId, 'global'], split.system, now);
+    deps.writeSettingsPayloadRow(store, 'user_preferences', [deps.tenantId, 'default', 'global'], split.userPreferences, now);
+}
+export function getGlobalSettingsService(deps) {
+    const global = readGlobalConfigService(deps);
+    const sourcePrefs = global.schedulePreferences || {};
+    const sourceCapacity = sourcePrefs.dailyCapacity || {};
+    const schedulePreferences = {
+        ...(typeof sourcePrefs.showWeekends === 'boolean' ? { showWeekends: sourcePrefs.showWeekends } : {}),
+        ...(typeof sourcePrefs.isCalendarSidebarOpen === 'boolean' ? { isCalendarSidebarOpen: sourcePrefs.isCalendarSidebarOpen } : {}),
+        ...((sourcePrefs.weekStartsOn === 'sunday' || sourcePrefs.weekStartsOn === 'monday') ? { weekStartsOn: sourcePrefs.weekStartsOn } : {}),
+        dailyCapacity: {
+            ...(typeof sourceCapacity.monday === 'number' ? { monday: sourceCapacity.monday } : {}),
+            ...(typeof sourceCapacity.tuesday === 'number' ? { tuesday: sourceCapacity.tuesday } : {}),
+            ...(typeof sourceCapacity.wednesday === 'number' ? { wednesday: sourceCapacity.wednesday } : {}),
+            ...(typeof sourceCapacity.thursday === 'number' ? { thursday: sourceCapacity.thursday } : {}),
+            ...(typeof sourceCapacity.friday === 'number' ? { friday: sourceCapacity.friday } : {}),
+            ...(typeof sourceCapacity.saturday === 'number' ? { saturday: sourceCapacity.saturday } : {}),
+            ...(typeof sourceCapacity.sunday === 'number' ? { sunday: sourceCapacity.sunday } : {})
+        }
+    };
+    return {
+        theme: normalizeTaskforceTheme(global.theme) ?? undefined,
+        shortcut: typeof global.shortcut === 'string' && global.shortcut.trim().length > 0 ? global.shortcut.trim() : undefined,
+        jsonBackupEnabled: typeof global.jsonBackupEnabled === 'boolean' ? global.jsonBackupEnabled : undefined,
+        realtimeSyncEnabled: typeof global.realtimeSyncEnabled === 'boolean' ? global.realtimeSyncEnabled : undefined,
+        ...(Object.keys(schedulePreferences.dailyCapacity).length > 0
+            || typeof schedulePreferences.showWeekends === 'boolean'
+            || typeof schedulePreferences.isCalendarSidebarOpen === 'boolean'
+            || schedulePreferences.weekStartsOn === 'sunday'
+            || schedulePreferences.weekStartsOn === 'monday'
+            ? { schedulePreferences }
+            : {}),
+        ...(global.email && typeof global.email === 'object'
+            ? {
+                email: {
+                    ...(global.email.provider === 'console' || global.email.provider === 'resend' || global.email.provider === 'google-workspace'
+                        ? { provider: global.email.provider }
+                        : {}),
+                    ...(typeof global.email.from === 'string' && global.email.from.trim().length > 0
+                        ? { from: global.email.from.trim() }
+                        : {}),
+                    ...(typeof global.email.replyTo === 'string' && global.email.replyTo.trim().length > 0
+                        ? { replyTo: global.email.replyTo.trim() }
+                        : {}),
+                    ...(typeof global.email.providerApiKey === 'string' && global.email.providerApiKey.trim().length > 0
+                        ? { providerApiKey: global.email.providerApiKey.trim() }
+                        : {})
+                }
+            }
+            : {}),
+        ...(global.auth && typeof global.auth === 'object'
+            ? {
+                auth: {
+                    ...(typeof global.auth.allowSelfRegistration === 'boolean'
+                        ? { allowSelfRegistration: global.auth.allowSelfRegistration }
+                        : {}),
+                    ...(typeof global.auth.requireVerifiedEmail === 'boolean'
+                        ? { requireVerifiedEmail: global.auth.requireVerifiedEmail }
+                        : {}),
+                    ...(typeof global.auth.defaultNewUserBetaAccess === 'boolean'
+                        ? { defaultNewUserBetaAccess: global.auth.defaultNewUserBetaAccess }
+                        : {}),
+                    ...(typeof global.auth.authRateLimitEnabled === 'boolean'
+                        ? { authRateLimitEnabled: global.auth.authRateLimitEnabled }
+                        : {}),
+                    ...(typeof global.auth.authRateLimitMaxRequests === 'number' && Number.isFinite(global.auth.authRateLimitMaxRequests)
+                        ? { authRateLimitMaxRequests: Math.max(1, Math.floor(global.auth.authRateLimitMaxRequests)) }
+                        : {}),
+                    ...(typeof global.auth.authRateLimitWindowMs === 'number' && Number.isFinite(global.auth.authRateLimitWindowMs)
+                        ? { authRateLimitWindowMs: Math.max(1000, Math.floor(global.auth.authRateLimitWindowMs)) }
+                        : {}),
+                    ...((global.auth.signupMonetizationStrategy === 'auto_assign_default' || global.auth.signupMonetizationStrategy === 'plan_selection_required')
+                        ? { signupMonetizationStrategy: global.auth.signupMonetizationStrategy }
+                        : {}),
+                    ...(typeof global.auth.defaultSignupPlanVersionId === 'string'
+                        ? { defaultSignupPlanVersionId: global.auth.defaultSignupPlanVersionId.trim() || null }
+                        : global.auth.defaultSignupPlanVersionId === null
+                            ? { defaultSignupPlanVersionId: null }
+                            : {})
+                }
+            }
+            : {}),
+        ...(global.site && typeof global.site === 'object'
+            ? {
+                site: {
+                    ...(typeof global.site.showRunTaskforceLocally === 'boolean'
+                        ? { showRunTaskforceLocally: global.site.showRunTaskforceLocally }
+                        : {}),
+                    ...(typeof global.site.pricingPageEnabled === 'boolean'
+                        ? { pricingPageEnabled: global.site.pricingPageEnabled }
+                        : {})
+                }
+            }
+            : {}),
+        ...(global.setup && typeof global.setup === 'object'
+            ? {
+                setup: {
+                    ...((global.setup.mode === 'core' || global.setup.mode === 'operations')
+                        ? { mode: global.setup.mode }
+                        : {}),
+                    ...(typeof global.setup.forceSetup === 'boolean'
+                        ? { forceSetup: global.setup.forceSetup }
+                        : {}),
+                    ...(typeof global.setup.forceGlobalSetup === 'boolean'
+                        ? { forceGlobalSetup: global.setup.forceGlobalSetup }
+                        : {}),
+                    ...(typeof global.setup.forceWorkspaceSetup === 'boolean'
+                        ? { forceWorkspaceSetup: global.setup.forceWorkspaceSetup }
+                        : {})
+                }
+            }
+            : {}),
+        ...(global.objectStorage && typeof global.objectStorage === 'object'
+            ? {
+                objectStorage: {
+                    ...(typeof global.objectStorage.keyPrefix === 'string'
+                        ? { keyPrefix: global.objectStorage.keyPrefix.trim() }
+                        : {}),
+                    ...(typeof global.objectStorage.signedUploadTtlSeconds === 'number' && Number.isFinite(global.objectStorage.signedUploadTtlSeconds)
+                        ? { signedUploadTtlSeconds: Math.max(1, Math.floor(global.objectStorage.signedUploadTtlSeconds)) }
+                        : {}),
+                    ...(typeof global.objectStorage.signedDownloadTtlSeconds === 'number' && Number.isFinite(global.objectStorage.signedDownloadTtlSeconds)
+                        ? { signedDownloadTtlSeconds: Math.max(1, Math.floor(global.objectStorage.signedDownloadTtlSeconds)) }
+                        : {})
+                }
+            }
+            : {})
+    };
+}
+export function updateGlobalSettingsService(deps, settings) {
+    const current = readGlobalConfigService(deps);
+    const next = { ...current };
+    const normalizedTheme = normalizeTaskforceTheme(settings.theme);
+    if (normalizedTheme) {
+        next.theme = normalizedTheme;
+    }
+    if (typeof settings.shortcut === 'string' && settings.shortcut.trim().length > 0) {
+        next.shortcut = settings.shortcut.trim();
+    }
+    if (deps.runtimeMode !== 'cloud' && typeof settings.jsonBackupEnabled === 'boolean') {
+        next.jsonBackupEnabled = settings.jsonBackupEnabled;
+    }
+    if (typeof settings.realtimeSyncEnabled === 'boolean') {
+        next.realtimeSyncEnabled = settings.realtimeSyncEnabled;
+    }
+    if (settings.schedulePreferences && typeof settings.schedulePreferences === 'object') {
+        const currentPrefs = next.schedulePreferences && typeof next.schedulePreferences === 'object'
+            ? next.schedulePreferences
+            : {};
+        const incomingPrefs = settings.schedulePreferences;
+        const mergedPrefs = {
+            ...currentPrefs,
+            ...(typeof incomingPrefs.showWeekends === 'boolean' ? { showWeekends: incomingPrefs.showWeekends } : {}),
+            ...(typeof incomingPrefs.isCalendarSidebarOpen === 'boolean' ? { isCalendarSidebarOpen: incomingPrefs.isCalendarSidebarOpen } : {}),
+            ...((incomingPrefs.weekStartsOn === 'sunday' || incomingPrefs.weekStartsOn === 'monday') ? { weekStartsOn: incomingPrefs.weekStartsOn } : {})
+        };
+        if (incomingPrefs.dailyCapacity && typeof incomingPrefs.dailyCapacity === 'object') {
+            const currentCapacity = currentPrefs.dailyCapacity && typeof currentPrefs.dailyCapacity === 'object'
+                ? currentPrefs.dailyCapacity
+                : {};
+            const mergedCapacity = {
+                ...currentCapacity,
+                ...Object.fromEntries(Object.entries(incomingPrefs.dailyCapacity).filter(([, value]) => typeof value === 'number' && Number.isFinite(value) && value >= 0))
+            };
+            mergedPrefs.dailyCapacity = mergedCapacity;
+        }
+        next.schedulePreferences = mergedPrefs;
+    }
+    if (settings.email && typeof settings.email === 'object') {
+        const currentEmail = next.email && typeof next.email === 'object' ? next.email : {};
+        const incoming = settings.email;
+        next.email = {
+            ...currentEmail,
+            ...(incoming.provider === 'console' || incoming.provider === 'resend' || incoming.provider === 'google-workspace'
+                ? { provider: incoming.provider }
+                : {}),
+            ...(typeof incoming.from === 'string' && incoming.from.trim().length > 0
+                ? { from: incoming.from.trim() }
+                : {}),
+            ...(typeof incoming.replyTo === 'string'
+                ? { replyTo: incoming.replyTo.trim() }
+                : {})
+        };
+        if (typeof incoming.providerApiKey === 'string') {
+            const trimmedApiKey = incoming.providerApiKey.trim();
+            if (trimmedApiKey.length > 0) {
+                next.email.providerApiKey = trimmedApiKey;
+            }
+            else if (next.email && typeof next.email === 'object') {
+                delete next.email.providerApiKey;
+            }
+        }
+    }
+    if (settings.auth && typeof settings.auth === 'object') {
+        const currentAuth = next.auth && typeof next.auth === 'object' ? next.auth : {};
+        const incoming = settings.auth;
+        next.auth = {
+            ...currentAuth,
+            ...(typeof incoming.allowSelfRegistration === 'boolean'
+                ? { allowSelfRegistration: incoming.allowSelfRegistration }
+                : {}),
+            ...(typeof incoming.requireVerifiedEmail === 'boolean'
+                ? { requireVerifiedEmail: incoming.requireVerifiedEmail }
+                : {}),
+            ...(typeof incoming.defaultNewUserBetaAccess === 'boolean'
+                ? { defaultNewUserBetaAccess: incoming.defaultNewUserBetaAccess }
+                : {}),
+            ...(typeof incoming.authRateLimitEnabled === 'boolean'
+                ? { authRateLimitEnabled: incoming.authRateLimitEnabled }
+                : {}),
+            ...(typeof incoming.authRateLimitMaxRequests === 'number' && Number.isFinite(incoming.authRateLimitMaxRequests)
+                ? { authRateLimitMaxRequests: Math.max(1, Math.floor(incoming.authRateLimitMaxRequests)) }
+                : {}),
+            ...(typeof incoming.authRateLimitWindowMs === 'number' && Number.isFinite(incoming.authRateLimitWindowMs)
+                ? { authRateLimitWindowMs: Math.max(1000, Math.floor(incoming.authRateLimitWindowMs)) }
+                : {}),
+            ...((incoming.signupMonetizationStrategy === 'auto_assign_default' || incoming.signupMonetizationStrategy === 'plan_selection_required')
+                ? { signupMonetizationStrategy: incoming.signupMonetizationStrategy }
+                : {}),
+            ...(typeof incoming.defaultSignupPlanVersionId === 'string'
+                ? { defaultSignupPlanVersionId: incoming.defaultSignupPlanVersionId.trim() || null }
+                : incoming.defaultSignupPlanVersionId === null
+                    ? { defaultSignupPlanVersionId: null }
+                    : {})
+        };
+    }
+    if (settings.site && typeof settings.site === 'object') {
+        const currentSite = next.site && typeof next.site === 'object' ? next.site : {};
+        const incoming = settings.site;
+        next.site = {
+            ...currentSite,
+            ...(typeof incoming.showRunTaskforceLocally === 'boolean'
+                ? { showRunTaskforceLocally: incoming.showRunTaskforceLocally }
+                : {}),
+            ...(typeof incoming.pricingPageEnabled === 'boolean'
+                ? { pricingPageEnabled: incoming.pricingPageEnabled }
+                : {})
+        };
+    }
+    if (settings.setup && typeof settings.setup === 'object') {
+        const currentSetup = next.setup && typeof next.setup === 'object' ? next.setup : {};
+        const incoming = settings.setup;
+        next.setup = {
+            ...currentSetup,
+            ...((incoming.mode === 'core' || incoming.mode === 'operations')
+                ? { mode: incoming.mode }
+                : {}),
+            ...(typeof incoming.forceSetup === 'boolean'
+                ? { forceSetup: incoming.forceSetup }
+                : {}),
+            ...(typeof incoming.forceGlobalSetup === 'boolean'
+                ? { forceGlobalSetup: incoming.forceGlobalSetup }
+                : {}),
+            ...(typeof incoming.forceWorkspaceSetup === 'boolean'
+                ? { forceWorkspaceSetup: incoming.forceWorkspaceSetup }
+                : {})
+        };
+    }
+    if (settings.objectStorage && typeof settings.objectStorage === 'object') {
+        const currentObjectStorage = next.objectStorage && typeof next.objectStorage === 'object' ? next.objectStorage : {};
+        const incoming = settings.objectStorage;
+        next.objectStorage = {
+            ...currentObjectStorage,
+            ...(typeof incoming.keyPrefix === 'string'
+                ? { keyPrefix: incoming.keyPrefix.trim().replace(/^\/+|\/+$/g, '') }
+                : {}),
+            ...(typeof incoming.signedUploadTtlSeconds === 'number' && Number.isFinite(incoming.signedUploadTtlSeconds)
+                ? { signedUploadTtlSeconds: Math.max(1, Math.floor(incoming.signedUploadTtlSeconds)) }
+                : {}),
+            ...(typeof incoming.signedDownloadTtlSeconds === 'number' && Number.isFinite(incoming.signedDownloadTtlSeconds)
+                ? { signedDownloadTtlSeconds: Math.max(1, Math.floor(incoming.signedDownloadTtlSeconds)) }
+                : {})
+        };
+    }
+    writeGlobalConfigService(deps, next);
+}

package/dist/core/JsonBackupRuntime.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/JsonBackupRuntime.test.js

@@ -0,0 +1,155 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TaskforceCore } from './Taskforce';
+const roots = [];
+function createProjectRoot(prefix) {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    roots.push(projectRoot);
+    return projectRoot;
+}
+afterEach(() => {
+    while (roots.length > 0) {
+        const root = roots.pop();
+        if (root)
+            fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('TaskforceCore JSON backup runtime behavior', () => {
+    it('does not persist tasks.json in cloud runtime even when project and global backup settings are enabled', () => {
+        const projectRoot = createProjectRoot('taskforce-json-backup-cloud-');
+        const core = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'cloud',
+            database: {
+                provider: 'sqlite'
+            }
+        });
+        core.updateConfig({ jsonBackupEnabled: true });
+        core.updateGlobalSettings({ jsonBackupEnabled: true });
+        core.createTask({ title: 'Cloud task' });
+        expect(core.getJsonBackupEnabled()).toBe(false);
+        expect(fs.existsSync(path.join(projectRoot, '.taskforce', 'tasks.json'))).toBe(false);
+        core.close();
+    });
+    it('persists tasks.json in local runtime when JSON backup is enabled', () => {
+        const projectRoot = createProjectRoot('taskforce-json-backup-local-');
+        const core = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        core.updateConfig({ jsonBackupEnabled: true });
+        core.createTask({ title: 'Local task' });
+        expect(core.getJsonBackupEnabled()).toBe(true);
+        expect(fs.existsSync(path.join(projectRoot, '.taskforce', 'tasks.json'))).toBe(true);
+        core.close();
+    });
+    it('persists generic project config settings in the database instead of config.json', () => {
+        const projectRoot = createProjectRoot('taskforce-project-config-db-');
+        const core = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        core.updateConfig({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        expect(core.getConfig()).toMatchObject({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        expect(core.getEffectiveTheme()).toBe('light');
+        expect(core.getJsonBackupEnabled()).toBe(true);
+        const configPath = path.join(projectRoot, '.taskforce', 'config.json');
+        expect(JSON.parse(fs.readFileSync(configPath, 'utf-8'))).toEqual({});
+        core.close();
+        const reopened = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        expect(reopened.getConfig()).toMatchObject({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        expect(reopened.getEffectiveTheme()).toBe('light');
+        expect(reopened.getJsonBackupEnabled()).toBe(true);
+        reopened.close();
+    });
+    it('stores theme, json backup, and checklist dropdown settings per user while keeping manual complexity shared', () => {
+        const projectRoot = createProjectRoot('taskforce-project-config-user-scope-');
+        const core = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        core.updateConfig({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        }, 'default', 'user-a');
+        expect(core.getConfig('default', 'user-a')).toMatchObject({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        const userBConfig = core.getConfig('default', 'user-b') || {};
+        expect(userBConfig).toMatchObject({
+            manualComplexityEnabled: true
+        });
+        expect(userBConfig.theme).toBeUndefined();
+        expect(userBConfig.jsonBackupEnabled).toBeUndefined();
+        expect(userBConfig.checklistDropdownEnabled).toBeUndefined();
+        expect(core.getEffectiveTheme('default', 'user-a')).toBe('light');
+        expect(core.getJsonBackupEnabled('default', 'user-a')).toBe(true);
+        expect(core.hasProjectThemeOverride('default', 'user-a')).toBe(true);
+        expect(core.hasProjectThemeOverride('default', 'user-b')).toBe(false);
+        core.close();
+    });
+    it('migrates legacy generic project config settings from config.json into the database', () => {
+        const projectRoot = createProjectRoot('taskforce-project-config-migration-');
+        const storagePath = path.join(projectRoot, '.taskforce');
+        fs.mkdirSync(storagePath, { recursive: true });
+        fs.writeFileSync(path.join(storagePath, 'config.json'), JSON.stringify({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true,
+            categories: [{ value: 'default', label: 'General', icon: 'Inbox' }]
+        }, null, 2));
+        const core = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        expect(core.getConfig()).toMatchObject({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        fs.writeFileSync(path.join(storagePath, 'config.json'), JSON.stringify({
+            categories: [{ value: 'default', label: 'General', icon: 'Inbox' }]
+        }, null, 2));
+        core.close();
+        const reopened = new TaskforceCore({
+            projectRoot,
+            runtimeMode: 'local'
+        });
+        expect(reopened.getConfig()).toMatchObject({
+            theme: 'light',
+            jsonBackupEnabled: true,
+            manualComplexityEnabled: true,
+            checklistDropdownEnabled: true
+        });
+        expect(reopened.getEffectiveTheme()).toBe('light');
+        expect(reopened.getJsonBackupEnabled()).toBe(true);
+        reopened.close();
+    });
+});