@taskforcehq/taskforce 0.3.168

package/dist/core/CreatedBy.test.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, it, expect } from 'vitest';
+import { TaskforceCore } from './Taskforce';
+function createProjectRoot(prefix = 'taskforce-created-by-') {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'created-by-test' }), 'utf-8');
+    return root;
+}
+const createdRoots = [];
+afterEach(() => {
+    while (createdRoots.length > 0) {
+        const root = createdRoots.pop();
+        if (root && fs.existsSync(root)) {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    }
+});
+describe('TaskforceCore - createdBy Field', () => {
+    it('populates createdBy field correctly on creation', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const task = core.createTask({
+            title: 'AI Task',
+            createdBy: 'AI Agent'
+        });
+        expect(task.createdBy).toBe('AI Agent');
+    });
+    it('defaults createdBy to undefined if not provided', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const task = core.createTask({ title: 'User Task' });
+        expect(task.createdBy).toBeUndefined();
+    });
+    it('infers assignee user from [User] title hint when assignee is missing', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const task = core.createTask({
+            title: '[User] Configure backups',
+            createdBy: 'AI Agent'
+        });
+        expect(task.assignee).toBe('user');
+    });
+    it('overrides unassigned with explicit owner hint for compatibility', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const task = core.createTask({
+            title: 'Configure alerts',
+            description: 'Owner: User',
+            assignee: 'unassigned',
+            createdBy: 'AI Agent'
+        });
+        expect(task.assignee).toBe('user');
+    });
+});

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

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

package/dist/core/EntitlementsPolicy.test.js

@@ -0,0 +1,145 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { TaskforceCore, TaskforceRuleError } from './Taskforce';
+function makeProjectRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-entitlements-'));
+}
+function openCore(projectRoot) {
+    return new TaskforceCore({
+        projectRoot,
+        storagePath: path.join(projectRoot, '.taskforce')
+    });
+}
+describe('Taskforce entitlements policy engine', () => {
+    it('counts active + invited + disabled seats and removal frees a seat', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-seat', name: 'Seat Workspace' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-seat',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.setUserAccountPlanMode('owner-u1', 'team');
+            core.ensureBootstrapUserAccess({
+                userId: 'member-u2',
+                workspaceId: 'workspace-seat',
+                role: 'member',
+                email: 'member2@example.com'
+            });
+            core.ensureBootstrapUserAccess({
+                userId: 'member-u3',
+                workspaceId: 'workspace-seat',
+                role: 'member',
+                email: 'member3@example.com'
+            });
+            core.setWorkspaceUserDisabled('member-u3', 'workspace-seat', true);
+            core.inviteWorkspaceUser({
+                workspaceId: 'workspace-seat',
+                email: 'invite4@example.com',
+                role: 'member'
+            });
+            const initial = core.countWorkspaceSeatUsage('workspace-seat', { includeInvited: true });
+            expect(initial.used).toBe(4);
+            expect(initial.limit).toBe(5);
+            expect(initial.remaining).toBe(1);
+            const inviteUser = core.listWorkspaceUsers('workspace-seat').find((item) => item.email === 'invite4@example.com');
+            expect(inviteUser?.status).toBe('invited');
+            core.removeWorkspaceUser(String(inviteUser?.userId || ''), 'workspace-seat');
+            const afterRemoval = core.countWorkspaceSeatUsage('workspace-seat', { includeInvited: true });
+            expect(afterRemoval.used).toBe(3);
+            expect(afterRemoval.remaining).toBe(2);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('blocks collaboration features when entitlement state is suspended', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-suspend', name: 'Suspend Workspace' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-suspend',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.setUserAccountPlanMode('owner-u1', 'team');
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                entitlementState: 'suspended',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            const evaluation = core.evaluateFeatureAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-suspend',
+                featureKey: 'collaboration.invites'
+            });
+            expect(evaluation.allowed).toBe(false);
+            expect(evaluation.reasonCode).toBe('ENTITLEMENT_STATE_BLOCKED');
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('enforces seat limits on invite path', () => {
+        const projectRoot = makeProjectRoot();
+        const core = openCore(projectRoot);
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-cap', name: 'Cap Workspace' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-cap',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.createPlanVersion({
+                planId: 'team',
+                versionNumber: 2,
+                isDefault: false,
+                seatLimit: 2
+            });
+            core.updatePlanVersionFeatures({
+                planVersionId: 'team-v2',
+                features: [
+                    { featureKey: 'collaboration.invites', access: 'enabled' },
+                    { featureKey: 'collaboration.team_management', access: 'enabled' },
+                    { featureKey: 'collaboration.seat_limit', access: 'limited', config: { seat_limit: 2 } }
+                ]
+            });
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                planVersionId: 'team-v2',
+                entitlementState: 'active',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            core.ensureBootstrapUserAccess({
+                userId: 'member-u2',
+                workspaceId: 'workspace-cap',
+                role: 'member',
+                email: 'member2@example.com'
+            });
+            expect(() => {
+                core.inviteWorkspaceUser({
+                    workspaceId: 'workspace-cap',
+                    email: 'member3@example.com',
+                    role: 'member'
+                });
+            }).toThrowError(TaskforceRuleError);
+            expect(() => core.assertSeatAvailable('workspace-cap')).toThrowError(TaskforceRuleError);
+        }
+        finally {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+});

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

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

package/dist/core/InitiativeTemplates.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TaskforceCore } from './Taskforce';
+function makeTempProjectRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-initiative-'));
+}
+describe('TaskforceCore initiative templates', () => {
+    it('returns launch/migration/incident templates', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const templates = core.getInitiativeTemplates();
+        expect(templates.map(t => t.id)).toEqual(expect.arrayContaining(['launch', 'migration', 'incident']));
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('creates initiative and milestone children from template', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = core.createInitiativeFromTemplate({
+            templateId: 'launch',
+            title: 'My Launch'
+        });
+        expect(created.initiative.id).toBeTruthy();
+        expect(created.milestones.length).toBeGreaterThan(0);
+        expect(created.milestones.every(m => m.parentTaskId === created.initiative.id)).toBe(true);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('clones checklist blocks to direct children in one action', () => {
+        const projectRoot = makeTempProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const parent = core.createTask({ title: 'Parent' });
+        const childA = core.createTask({ title: 'Child A', parentTaskId: parent.id });
+        core.createTask({ title: 'Child B', parentTaskId: parent.id });
+        core.createTask({ title: 'Other Parent Child', parentTaskId: childA.id });
+        const result = core.cloneChecklistBlocksToChildren({
+            parentTaskId: parent.id,
+            checklistBlocks: {
+                definitionOfDone: ['Done A'],
+                rollbackPlan: ['Rollback A']
+            }
+        });
+        expect(result.updated).toBe(2);
+        expect(result.children.length).toBe(2);
+        core.close();
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+    });
+});

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

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

package/dist/core/ParentLifecycle.test.js

@@ -0,0 +1,98 @@
+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 createCore() {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-parent-lifecycle-'));
+    roots.push(projectRoot);
+    return new TaskforceCore({ projectRoot });
+}
+afterEach(() => {
+    while (roots.length > 0) {
+        const root = roots.pop();
+        if (root)
+            fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('TaskforceCore parent lifecycle', () => {
+    it('auto-completes parent chain when all descendants are terminal', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
+        const updatedGrandchild = core.updateTask(grandchild.id, { status: 'done' });
+        const updatedChild = core.getTask(child.id);
+        const updatedParent = core.getTask(parent.id);
+        expect(updatedGrandchild?.status).toBe('done');
+        expect(updatedChild?.status).toBe('done');
+        expect(updatedParent?.status).toBe('done');
+        core.close();
+    });
+    it('keeps parent open when any descendant remains open', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const doneChild = core.createTask({ title: 'Done Child', parentTaskId: parent.id, status: 'done' });
+        const openChild = core.createTask({ title: 'Open Child', parentTaskId: parent.id, status: 'task' });
+        const refreshedParent = core.getTask(parent.id);
+        expect(doneChild.status).toBe('done');
+        expect(openChild.status).toBe('task');
+        expect(refreshedParent?.status).toBe('task');
+        core.close();
+    });
+    it('reopens done parent when a new open descendant is added', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        core.updateTask(child.id, { status: 'done' });
+        expect(core.getTask(parent.id)?.status).toBe('done');
+        core.createTask({ title: 'New Child', parentTaskId: parent.id, status: 'task' });
+        expect(core.getTask(parent.id)?.status).toBe('task');
+        core.close();
+    });
+    it('does not reopen cancelled parent when open descendant is added', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        core.updateTask(parent.id, { status: 'cancelled' });
+        core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        expect(core.getTask(parent.id)?.status).toBe('cancelled');
+        core.close();
+    });
+    it('blocks manual done on parent tasks', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        expect(() => core.updateTask(parent.id, { status: 'done' })).toThrow(/Parent tasks cannot be marked done manually/);
+        core.close();
+    });
+    it('cancels open descendants in cascade mode', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
+        const cancelledParent = core.cancelParentWithOpenDescendants(parent.id, { mode: 'cascade', reason: 'No longer needed' });
+        const refreshedChild = core.getTask(child.id);
+        const refreshedGrandchild = core.getTask(grandchild.id);
+        expect(cancelledParent?.status).toBe('cancelled');
+        expect(cancelledParent?.canceledReason).toBe('No longer needed');
+        expect(refreshedChild?.status).toBe('cancelled');
+        expect(refreshedGrandchild?.status).toBe('cancelled');
+        core.close();
+    });
+    it('unlinks open descendants in unlink mode and cancels only parent', () => {
+        const core = createCore();
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        const grandchild = core.createTask({ title: 'Grandchild', parentTaskId: child.id, status: 'task' });
+        const cancelledParent = core.cancelParentWithOpenDescendants(parent.id, { mode: 'unlink', reason: 'No longer needed' });
+        const refreshedChild = core.getTask(child.id);
+        const refreshedGrandchild = core.getTask(grandchild.id);
+        expect(cancelledParent?.status).toBe('cancelled');
+        expect(refreshedChild?.status).toBe('task');
+        expect(refreshedGrandchild?.status).toBe('task');
+        expect(refreshedChild?.parentTaskId).toBeNull();
+        expect(refreshedGrandchild?.parentTaskId).toBeNull();
+        core.close();
+    });
+});

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

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

package/dist/core/ScheduleFields.test.js

@@ -0,0 +1,197 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TaskforceCore } from './Taskforce';
+const roots = [];
+function makeRoot(prefix) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    roots.push(root);
+    return root;
+}
+function localDateOffset(days) {
+    const date = new Date();
+    date.setDate(date.getDate() + days);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+afterEach(() => {
+    while (roots.length > 0) {
+        const root = roots.pop();
+        if (root)
+            fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('TaskforceCore schedule fields', () => {
+    it('persists and reads schedule fields on create/update', () => {
+        const projectRoot = makeRoot('taskforce-schedule-fields-');
+        const core = new TaskforceCore({ projectRoot });
+        const created = core.createTask({
+            title: 'Schedule Roundtrip',
+            scheduledDate: '2026-02-16',
+            dueDate: '2026-02-15',
+            scheduledWeekKey: '2026-W08',
+            orderInDay: 2
+        });
+        expect(created.scheduledDate).toBe('2026-02-16');
+        expect(created.dueDate).toBe('2026-02-15');
+        expect(created.scheduledWeekKey).toBe('2026-W08');
+        expect(created.orderInDay).toBe(2);
+        const updated = core.updateTask(created.id, {
+            scheduledDate: 'invalid-date',
+            orderInDay: -5,
+            dueDate: null
+        });
+        expect(updated?.scheduledDate).toBeNull();
+        expect(updated?.orderInDay).toBeNull();
+        expect(updated?.dueDate).toBeNull();
+        core.close();
+    });
+    it('normalizes blocked status alias to on-hold', () => {
+        const projectRoot = makeRoot('taskforce-status-alias-');
+        const core = new TaskforceCore({ projectRoot });
+        const created = core.createTask({
+            title: 'Blocked alias',
+            status: 'blocked'
+        });
+        expect(created.status).toBe('on-hold');
+        const updated = core.updateTask(created.id, { status: 'blocked' });
+        expect(updated?.status).toBe('on-hold');
+        core.close();
+    });
+    it('migrates existing database schema with schedule columns', () => {
+        const projectRoot = makeRoot('taskforce-schedule-schema-');
+        const storageRoot = path.join(projectRoot, '.taskforce');
+        fs.mkdirSync(storageRoot, { recursive: true });
+        const dbPath = path.join(storageRoot, 'taskforce.db');
+        const legacyDb = new Database(dbPath);
+        legacyDb.exec(`
+            CREATE TABLE IF NOT EXISTS tasks (
+                id TEXT PRIMARY KEY,
+                title TEXT NOT NULL,
+                description TEXT,
+                status TEXT NOT NULL,
+                priority INTEGER DEFAULT 2,
+                complexity INTEGER DEFAULT 3,
+                type TEXT DEFAULT 'feature',
+                category TEXT DEFAULT 'general',
+                approach TEXT,
+                created_at TEXT NOT NULL,
+                updated_at TEXT,
+                completed_at TEXT,
+                canceled_reason TEXT,
+                is_archived BOOLEAN DEFAULT 0,
+                specialists TEXT,
+                taxonomies TEXT,
+                created_by TEXT
+            );
+        `);
+        legacyDb.close();
+        const core = new TaskforceCore({ projectRoot });
+        core.close();
+        const upgradedDb = new Database(dbPath, { readonly: true });
+        const columns = upgradedDb.prepare(`PRAGMA table_info(tasks)`).all();
+        upgradedDb.close();
+        const names = new Set(columns.map((c) => c.name));
+        expect(names.has('scheduled_date')).toBe(true);
+        expect(names.has('due_date')).toBe(true);
+        expect(names.has('scheduled_week_key')).toBe(true);
+        expect(names.has('order_in_day')).toBe(true);
+    });
+    it('blocks scheduling parent tasks and surfaces expired bucket', () => {
+        const projectRoot = makeRoot('taskforce-schedule-rules-');
+        const core = new TaskforceCore({ projectRoot });
+        const parent = core.createTask({ title: 'Parent', status: 'task' });
+        const child = core.createTask({ title: 'Child', parentTaskId: parent.id, status: 'task' });
+        expect(() => {
+            core.updateTaskSchedule(parent.id, { scheduledDate: localDateOffset(1), orderInDay: 0 });
+        }).toThrowError(/Only leaf tasks can be scheduled/);
+        const scheduled = core.updateTaskSchedule(child.id, { scheduledDate: localDateOffset(-1), orderInDay: 0 });
+        expect(scheduled?.task.scheduledDate).toBe(localDateOffset(-1));
+        const currentWeek = core.getScheduleBoard(`${new Date().getFullYear()}-W01`);
+        expect(Array.isArray(currentWeek.columns.expired)).toBe(true);
+        expect(currentWeek.columns.expired.some((task) => task.id === child.id)).toBe(true);
+        core.close();
+    });
+    it('returns schedule board day columns sorted by orderInDay', () => {
+        const projectRoot = makeRoot('taskforce-schedule-order-');
+        const core = new TaskforceCore({ projectRoot });
+        const date = localDateOffset(1);
+        const t1 = core.createTask({ title: 'A', scheduledDate: date, orderInDay: 2, status: 'task' });
+        const t2 = core.createTask({ title: 'B', scheduledDate: date, orderInDay: 0, status: 'task' });
+        const t3 = core.createTask({ title: 'C', scheduledDate: date, orderInDay: 1, status: 'task' });
+        const weekKey = t1.scheduledWeekKey || '';
+        expect(weekKey).toMatch(/^\d{4}-W\d{2}$/);
+        const board = core.getScheduleBoard(weekKey, true);
+        const dayKey = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'].find((key) => board.columns[key]?.some((task) => task.id === t1.id));
+        expect(dayKey).toBeTruthy();
+        const ids = (board.columns[dayKey] || []).map((task) => task.id);
+        expect(ids).toEqual([t2.id, t3.id, t1.id]);
+        core.close();
+    });
+    it('allows non-schedule updates on tasks with children even if legacy scheduledDate exists', () => {
+        const projectRoot = makeRoot('taskforce-schedule-non-schedule-update-');
+        const core = new TaskforceCore({ projectRoot });
+        const parent = core.createTask({ title: 'Top Parent', status: 'task' });
+        const middle = core.createTask({
+            title: 'Middle',
+            status: 'task',
+            scheduledDate: localDateOffset(1),
+            parentTaskId: parent.id
+        });
+        core.createTask({ title: 'Leaf', parentTaskId: middle.id, status: 'task' });
+        // Non-schedule mutations should remain allowed so users can repair hierarchy links.
+        const updated = core.updateTask(middle.id, { parentTaskId: null });
+        expect(updated?.parentTaskId).toBeNull();
+        expect(updated?.scheduledDate).toBe(localDateOffset(1));
+        core.close();
+    });
+    it('persists explicit order updates for unscheduled backlog tasks', () => {
+        const projectRoot = makeRoot('taskforce-backlog-order-');
+        const core = new TaskforceCore({ projectRoot });
+        const a = core.createTask({ title: 'Backlog A', status: 'task' });
+        const b = core.createTask({ title: 'Backlog B', status: 'task' });
+        const updatedA = core.updateTask(a.id, { orderInDay: 1 });
+        const updatedB = core.updateTask(b.id, { orderInDay: 0 });
+        expect(updatedA?.scheduledDate).toBeNull();
+        expect(updatedB?.scheduledDate).toBeNull();
+        expect(updatedA?.orderInDay).toBe(1);
+        expect(updatedB?.orderInDay).toBe(0);
+        const list = core.listTasks().tasks.filter((t) => t.id === a.id || t.id === b.id);
+        const byId = new Map(list.map((t) => [t.id, t]));
+        expect(byId.get(a.id)?.orderInDay).toBe(1);
+        expect(byId.get(b.id)?.orderInDay).toBe(0);
+        core.close();
+    });
+    it('persists schedule preferences in global settings', () => {
+        const projectRoot = makeRoot('taskforce-schedule-prefs-');
+        const fakeHome = makeRoot('taskforce-home-');
+        const previousHome = process.env.HOME;
+        process.env.HOME = fakeHome;
+        try {
+            const core = new TaskforceCore({ projectRoot });
+            core.updateGlobalSettings({
+                schedulePreferences: {
+                    showWeekends: true,
+                    isCalendarSidebarOpen: false,
+                    dailyCapacity: {
+                        monday: 8,
+                        friday: 5
+                    }
+                }
+            });
+            const updated = core.getGlobalSettings();
+            expect(updated.schedulePreferences?.showWeekends).toBe(true);
+            expect(updated.schedulePreferences?.isCalendarSidebarOpen).toBe(false);
+            expect(updated.schedulePreferences?.dailyCapacity?.monday).toBe(8);
+            expect(updated.schedulePreferences?.dailyCapacity?.friday).toBe(5);
+            core.close();
+        }
+        finally {
+            process.env.HOME = previousHome;
+        }
+    });
+});

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

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