@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/utils/taskSearch.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeTaskReferenceToken, normalizeTaskSearchQuery, taskMatchesSearch, } from './taskSearch';
-function makeTask(overrides = {}) {
-    return {
-        id: overrides.id || 'task-1',
-        title: overrides.title || 'Task',
-        description: overrides.description ?? null,
-        status: overrides.status || 'task',
-        priority: overrides.priority ?? 2,
-        complexity: overrides.complexity ?? 3,
-        type: overrides.type || 'feature',
-        category: overrides.category || 'default',
-        createdAt: overrides.createdAt || '2026-03-23T00:00:00.000Z',
-        updatedAt: overrides.updatedAt || null,
-        completedAt: overrides.completedAt || null,
-        assignee: overrides.assignee || 'unassigned',
-        comments: [],
-        attachments: [],
-        activity: [],
-        taskEvents: [],
-        referenceLabel: overrides.referenceLabel,
-        taxonomies: overrides.taxonomies || {}
-    };
-}
-describe('taskSearch', () => {
-    it('normalizes common pasted task reference formats', () => {
-        expect(normalizeTaskReferenceToken(' T-123 ')).toBe('t-123');
-        expect(normalizeTaskReferenceToken('T - 123')).toBe('t-123');
-        expect(normalizeTaskReferenceToken('T 123')).toBe('t-123');
-        expect(normalizeTaskReferenceToken('t–123')).toBe('t-123');
-        expect(normalizeTaskReferenceToken('LT - 45')).toBe('lt-45');
-    });
-    it('matches canonicalized task references', () => {
-        const task = makeTask({ referenceLabel: 'T-123' });
-        expect(taskMatchesSearch(task, normalizeTaskSearchQuery('T - 123'))).toBe(true);
-        expect(taskMatchesSearch(task, normalizeTaskSearchQuery('t–123'))).toBe(true);
-    });
-    it('matches all query tokens across task text', () => {
-        const task = makeTask({ title: 'Billing cleanup', description: 'Audit the API handlers' });
-        expect(taskMatchesSearch(task, 'api billing')).toBe(true);
-        expect(taskMatchesSearch(task, 'api invoices')).toBe(false);
-    });
-    it('matches task metadata labels', () => {
-        const task = makeTask({
-            category: 'ops',
-            type: 'bug',
-            priority: 3,
-            assignee: 'member-1',
-            taxonomies: { track: 'platform' }
-        });
-        const context = {
-            categories: [{ value: 'ops', label: 'Operations', disabled: false }],
-            types: [{ value: 'bug', label: 'Bug' }],
-            priorities: [{ value: 3, label: 'High' }],
-            assigneeOptions: [{ value: 'member-1', label: 'Member One', icon: 'User', color: '#22c55e', kind: 'member' }],
-            taxonomies: [{
-                    id: 'track',
-                    label: 'Track',
-                    options: [{ value: 'platform', label: 'Platform' }],
-                    widgetType: 'select',
-                    isSystem: false,
-                    multiSelect: false
-                }]
-        };
-        expect(taskMatchesSearch(task, 'operations', context)).toBe(true);
-        expect(taskMatchesSearch(task, 'member one', context)).toBe(true);
-        expect(taskMatchesSearch(task, 'track platform', context)).toBe(true);
-    });
-});

package/dist/utils/taskUtils.test.d.ts

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

package/dist/utils/taskUtils.test.js

@@ -1,19 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
-import { renderHighlighted } from './taskUtils';
-describe('renderHighlighted', () => {
-    it('highlights matches when the query has surrounding spaces', () => {
-        const { container } = render(_jsx("p", { children: renderHighlighted('T-123', ' T-123 ') }));
-        expect(container.querySelector('mark')?.textContent).toBe('T-123');
-    });
-    it('highlights task references when the query has pasted formatting', () => {
-        const { container } = render(_jsx("p", { children: renderHighlighted('T-123', ' T - 123 ') }));
-        expect(container.querySelector('mark')?.textContent).toBe('T-123');
-    });
-    it('treats whitespace-only queries as empty', () => {
-        const { container } = render(_jsx("p", { children: renderHighlighted('T-123', '   ') }));
-        expect(container.querySelector('mark')).toBeNull();
-        expect(container.textContent).toBe('T-123');
-    });
-});

package/dist/utils/taskforceApiClient.test.d.ts

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

package/dist/utils/taskforceApiClient.test.js

@@ -1,44 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchTaskforceApi, persistLocalMutationActorUserId, readLocalMutationActorUserId, } from './taskforceApiClient';
-describe('taskforceApiClient local mutation actor header', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        persistLocalMutationActorUserId(null);
-        window.history.replaceState({}, '', '/');
-    });
-    afterEach(() => {
-        persistLocalMutationActorUserId(null);
-    });
-    it('adds the local mutation actor header on same-origin taskforce api requests', async () => {
-        const fetchMock = vi.fn().mockResolvedValue(new Response('{}', { status: 200 }));
-        vi.stubGlobal('fetch', fetchMock);
-        persistLocalMutationActorUserId('user-test-06');
-        await fetchTaskforceApi('/api/taskforce/annotated-attachments/sessions', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: '{}',
-        });
-        expect(readLocalMutationActorUserId()).toBe('user-test-06');
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        const [, init] = fetchMock.mock.calls[0];
-        const headers = new Headers(init.headers);
-        expect(headers.get('x-taskforce-user-id')).toBe('user-test-06');
-        expect(headers.get('content-type')).toBe('application/json');
-    });
-    it('does not override an explicit user id header', async () => {
-        const fetchMock = vi.fn().mockResolvedValue(new Response('{}', { status: 200 }));
-        vi.stubGlobal('fetch', fetchMock);
-        persistLocalMutationActorUserId('user-test-06');
-        await fetchTaskforceApi('/api/taskforce/annotated-attachments/sessions', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-taskforce-user-id': 'user-explicit',
-            },
-            body: '{}',
-        });
-        const [, init] = fetchMock.mock.calls[0];
-        const headers = new Headers(init.headers);
-        expect(headers.get('x-taskforce-user-id')).toBe('user-explicit');
-    });
-});

package/dist/utils/taxonomyFormDefaults.test.d.ts

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

package/dist/utils/taxonomyFormDefaults.test.js

@@ -1,63 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildDefaultFormTaxonomies, getVisibleTaskFormTaxonomies } from './taxonomyFormDefaults';
-describe('taxonomy form defaults', () => {
-    it('builds default form values from configured taxonomy defaults', () => {
-        const taxonomies = [
-            {
-                id: 'review-status',
-                label: 'Review Status',
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                defaultValue: 'pending',
-                options: [{ value: 'pending', label: 'Pending', status: 'active' }]
-            },
-            {
-                id: 'channels',
-                label: 'Channels',
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: true,
-                defaultValue: ['email', 'web'],
-                options: [
-                    { value: 'email', label: 'Email', status: 'active' },
-                    { value: 'web', label: 'Web', status: 'active' }
-                ]
-            }
-        ];
-        expect(buildDefaultFormTaxonomies(taxonomies)).toEqual({
-            'review-status': 'pending',
-            channels: ['email', 'web']
-        });
-    });
-    it('shows hidden taxonomies when they are required or already selected', () => {
-        const taxonomies = [
-            {
-                id: 'hidden-taxonomy',
-                label: 'Hidden Taxonomy',
-                formEnabled: false,
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                options: [{ value: 'value-a', label: 'Value A', status: 'active' }]
-            },
-            {
-                id: 'required-taxonomy',
-                label: 'Required Taxonomy',
-                formEnabled: false,
-                isRequired: true,
-                widgetType: 'select',
-                isSystem: false,
-                multiSelect: false,
-                options: [{ value: 'value-b', label: 'Value B', status: 'active' }]
-            }
-        ];
-        expect(getVisibleTaskFormTaxonomies(taxonomies, {})).toEqual([
-            expect.objectContaining({ id: 'required-taxonomy' })
-        ]);
-        expect(getVisibleTaskFormTaxonomies(taxonomies, { 'hidden-taxonomy': 'value-a' })).toEqual([
-            expect.objectContaining({ id: 'hidden-taxonomy' }),
-            expect.objectContaining({ id: 'required-taxonomy' })
-        ]);
-    });
-});

package/dist/utils/uiNotice.test.d.ts

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

package/dist/utils/uiNotice.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveUiNoticeTtl } from './uiNotice';
-describe('resolveUiNoticeTtl', () => {
-    it('uses default ttl for success/info notices', () => {
-        expect(resolveUiNoticeTtl('success')).toBe(2600);
-        expect(resolveUiNoticeTtl('info')).toBe(2600);
-    });
-    it('uses default ttl for error notices', () => {
-        expect(resolveUiNoticeTtl('error')).toBe(3600);
-    });
-    it('accepts an explicit positive ttl', () => {
-        expect(resolveUiNoticeTtl('success', 1500)).toBe(1500);
-    });
-    it('ignores invalid ttl values', () => {
-        expect(resolveUiNoticeTtl('success', 0)).toBe(2600);
-        expect(resolveUiNoticeTtl('error', -1)).toBe(3600);
-    });
-});

package/dist/utils/workspaceIdentity.test.d.ts

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

package/dist/utils/workspaceIdentity.test.js

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { RESERVED_WORKSPACE_ID, WORKSPACE_BOOTSTRAP_SCOPE, generateWorkspaceId, isReservedWorkspaceId, isUsableWorkspaceId, normalizeWorkspaceStorageScopeLegacy, normalizeWorkspaceStorageScope, resolveWorkspaceSelectionScopeForRuntime, resolveWorkspaceStorageScopeForRuntime, resolveWorkspaceUiStateScopeForRuntime, resolveWorkspaceStorageScopeFromProjectRoot } from './workspaceIdentity';
-describe('workspace identity invariants', () => {
-    it('uses bootstrap scope when project root is unavailable', () => {
-        expect(resolveWorkspaceStorageScopeFromProjectRoot('')).toBe(WORKSPACE_BOOTSTRAP_SCOPE);
-        expect(normalizeWorkspaceStorageScope('')).toBe(WORKSPACE_BOOTSTRAP_SCOPE);
-    });
-    it('normalizes project-root-derived scope with stable hash suffix', () => {
-        const scope = resolveWorkspaceStorageScopeFromProjectRoot('/Users/ross/My Project');
-        expect(scope.startsWith('users-ross-my-project-')).toBe(true);
-        expect(scope.length).toBeGreaterThan('users-ross-my-project-'.length);
-    });
-    it('uses workspace-specific scope for cloud workspaces', () => {
-        const scope = resolveWorkspaceUiStateScopeForRuntime({
-            runtimeMode: 'cloud',
-            workspaceId: 'workspace-cloud-123'
-        });
-        expect(scope.startsWith('cloud-workspace-workspace-cloud-123-')).toBe(true);
-        expect(scope).not.toBe(WORKSPACE_BOOTSTRAP_SCOPE);
-    });
-    it('falls back to bootstrap scope for default cloud workspace id', () => {
-        expect(resolveWorkspaceUiStateScopeForRuntime({
-            runtimeMode: 'cloud',
-            workspaceId: 'default'
-        })).toBe(WORKSPACE_BOOTSTRAP_SCOPE);
-    });
-    it('uses bootstrap scope as the stable selection scope in cloud mode', () => {
-        expect(resolveWorkspaceSelectionScopeForRuntime({
-            runtimeMode: 'cloud',
-            projectRoot: '/Users/ross/My Project'
-        })).toBe(WORKSPACE_BOOTSTRAP_SCOPE);
-    });
-    it('keeps storage-scope compatibility helper aligned with ui state scope resolution', () => {
-        expect(resolveWorkspaceStorageScopeForRuntime({
-            runtimeMode: 'cloud',
-            workspaceId: 'workspace-cloud-123'
-        })).toBe(resolveWorkspaceUiStateScopeForRuntime({
-            runtimeMode: 'cloud',
-            workspaceId: 'workspace-cloud-123'
-        }));
-    });
-    it('keeps legacy scope normalization for migration fallback', () => {
-        expect(normalizeWorkspaceStorageScopeLegacy('/Users/ross/My Project')).toBe('users-ross-my-project');
-    });
-    it('avoids collisions for similarly normalized path variants', () => {
-        const a = normalizeWorkspaceStorageScope('/Users/ross/Maple Valley Group');
-        const b = normalizeWorkspaceStorageScope('/Users/ross/Maple-Valley-Group');
-        expect(a).not.toBe(b);
-    });
-    it('never treats default as usable workspace id', () => {
-        expect(isReservedWorkspaceId(RESERVED_WORKSPACE_ID)).toBe(true);
-        expect(isReservedWorkspaceId(' Default ')).toBe(true);
-        expect(isUsableWorkspaceId('default')).toBe(false);
-        expect(isUsableWorkspaceId('workspace-123')).toBe(true);
-    });
-    it('generates non-default workspace ids with workspace- prefix', () => {
-        const id = generateWorkspaceId();
-        expect(id.startsWith('workspace-')).toBe(true);
-        expect(id.toLowerCase()).not.toBe(RESERVED_WORKSPACE_ID);
-    });
-});

package/dist/utils/workspaceLifecycle.test.d.ts

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

package/dist/utils/workspaceLifecycle.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveWorkspaceLifecycleState } from './workspaceLifecycle';
-function makeSetupState(partial) {
-    return {
-        globalSetupState: 'present',
-        workspaceSetupState: 'present',
-        runtimeMode: 'local',
-        workspaceId: 'workspace-1',
-        mode: 'core',
-        forceSetup: false,
-        forceGlobalSetup: false,
-        forceWorkspaceSetup: false,
-        ...partial
-    };
-}
-describe('workspace lifecycle state resolver', () => {
-    it('returns ready when setup state is not available', () => {
-        const resolved = resolveWorkspaceLifecycleState({
-            setupState: null,
-            runtimeMode: 'local',
-            isAuthenticated: false
-        });
-        expect(resolved.phase).toBe('ready');
-        expect(resolved.setupGateActive).toBe(false);
-    });
-    it('requires workspace setup for local missing workspace', () => {
-        const resolved = resolveWorkspaceLifecycleState({
-            setupState: makeSetupState({ workspaceSetupState: 'missing' }),
-            runtimeMode: 'local',
-            isAuthenticated: false
-        });
-        expect(resolved.setupGateActive).toBe(true);
-        expect(resolved.needsWorkspaceSetup).toBe(true);
-        expect(resolved.phase).toBe('needs-workspace-setup');
-    });
-    it('requires workspace setup in cloud only when authenticated', () => {
-        const unauthenticated = resolveWorkspaceLifecycleState({
-            setupState: makeSetupState({ workspaceSetupState: 'missing' }),
-            runtimeMode: 'cloud',
-            isAuthenticated: false
-        });
-        expect(unauthenticated.setupGateActive).toBe(false);
-        expect(unauthenticated.phase).toBe('ready');
-        const authenticated = resolveWorkspaceLifecycleState({
-            setupState: makeSetupState({ workspaceSetupState: 'missing' }),
-            runtimeMode: 'cloud',
-            isAuthenticated: true
-        });
-        expect(authenticated.setupGateActive).toBe(true);
-        expect(authenticated.needsWorkspaceSetup).toBe(true);
-    });
-    it('prioritizes unreadable setup state as setup-read-error', () => {
-        const resolved = resolveWorkspaceLifecycleState({
-            setupState: makeSetupState({
-                globalSetupState: 'unreadable',
-                forceGlobalSetup: true
-            }),
-            runtimeMode: 'local',
-            isAuthenticated: false
-        });
-        expect(resolved.hasSetupReadError).toBe(true);
-        expect(resolved.phase).toBe('setup-read-error');
-    });
-});

package/dist/utils/workspaceSyncPresentation.test.d.ts

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

package/dist/utils/workspaceSyncPresentation.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveHeaderWorkspaceSyncPresentation } from './workspaceSyncPresentation';
-describe('resolveHeaderWorkspaceSyncPresentation', () => {
-    it('forces the header sync badge off when the local runtime is signed out', () => {
-        const result = resolveHeaderWorkspaceSyncPresentation({
-            runtimeMode: 'local',
-            isAuthenticated: false,
-            workspaceSyncStatus: 'healthy',
-            workspaceCloudSyncEnabled: true,
-            workspaceSyncSummary: 'Sync is healthy.',
-            workspaceSyncRecommendedAction: 'No action needed.',
-            workspaceSyncError: 'None'
-        });
-        expect(result.actionable).toBe(false);
-        expect(result.status).toBe('off');
-        expect(result.syncEnabledLabel).toBe('no');
-        expect(result.summary).toContain('Sign in');
-        expect(result.recommendedAction).toContain('Sign in');
-    });
-    it('keeps the current sync status when sync is actionable', () => {
-        const result = resolveHeaderWorkspaceSyncPresentation({
-            runtimeMode: 'local',
-            isAuthenticated: true,
-            workspaceSyncStatus: 'attention',
-            workspaceCloudSyncEnabled: true,
-            workspaceSyncSummary: 'Sync needs attention before it can continue.',
-            workspaceSyncRecommendedAction: 'Press Sync to retry.',
-            workspaceSyncError: 'Retry later',
-            pushBlockedReason: null,
-            pullBlockedReason: null,
-            retryBlockedReason: null
-        });
-        expect(result.actionable).toBe(true);
-        expect(result.status).toBe('attention');
-        expect(result.syncEnabledLabel).toBe('yes');
-        expect(result.summary).toBe('Sync needs attention before it can continue.');
-        expect(result.lastError).toBe('Retry later');
-    });
-    it('surfaces the highest-priority blocked sync reason in the visible summary', () => {
-        const result = resolveHeaderWorkspaceSyncPresentation({
-            runtimeMode: 'local',
-            isAuthenticated: true,
-            workspaceSyncStatus: 'attention',
-            workspaceCloudSyncEnabled: true,
-            workspaceSyncSummary: 'Sync needs attention before it can continue.',
-            workspaceSyncRecommendedAction: 'Press Sync to retry.',
-            workspaceSyncError: 'Retry later',
-            pushBlockedReason: 'attach-cloud',
-            pullBlockedReason: 'retry-pending',
-            retryBlockedReason: 'auth-required'
-        });
-        expect(result.summary).toBe('Sync is paused until you sign in again.');
-        expect(result.recommendedAction).toBe('Sign in, then press Sync to retry.');
-    });
-    it('explains when another local window holds the sync lease', () => {
-        const result = resolveHeaderWorkspaceSyncPresentation({
-            runtimeMode: 'local',
-            isAuthenticated: true,
-            workspaceSyncStatus: 'attention',
-            workspaceCloudSyncEnabled: true,
-            workspaceSyncSummary: 'Sync needs attention before it can continue.',
-            workspaceSyncRecommendedAction: 'Press Sync to retry.',
-            workspaceSyncError: 'Retry later',
-            pushBlockedReason: 'lease-held',
-            pullBlockedReason: null,
-            retryBlockedReason: null
-        });
-        expect(result.summary).toBe('Another local window is already syncing this workspace.');
-        expect(result.recommendedAction).toBe('Use a single local window for sync, or close the other syncing window.');
-    });
-});

package/scripts/bootstrap-playwright-auth.mjs

@@ -1,155 +0,0 @@
-import { chromium } from '@playwright/test';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-function asNonEmpty(value) {
-    return String(value || '').trim();
-}
-
-function resolveBaseUrl() {
-    const raw = asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_CLOUD_BASE_URL)
-        || asNonEmpty(process.env.SYNC_SOAK_CLOUD_BASE_URL)
-        || 'https://app.taskforcehq.ai';
-    return raw.replace(/\/+$/, '');
-}
-
-function resolveStorageStatePath() {
-    return asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_STORAGE_STATE)
-        || path.join(os.homedir(), '.codex', 'playwright', 'taskforce-cloud-auth.json');
-}
-
-function resolveCredentials() {
-    const email = asNonEmpty(process.env.TASKFORCE_E2E_EMAIL) || asNonEmpty(process.env.SYNC_SOAK_EMAIL);
-    const password = asNonEmpty(process.env.TASKFORCE_E2E_PASSWORD) || asNonEmpty(process.env.SYNC_SOAK_PASSWORD);
-    if (!email || !password) {
-        throw new Error(
-            'Missing credentials. Set TASKFORCE_E2E_EMAIL/TASKFORCE_E2E_PASSWORD or SYNC_SOAK_EMAIL/SYNC_SOAK_PASSWORD.'
-        );
-    }
-    return { email, password };
-}
-
-async function ensureParentDir(filePath) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-}
-
-async function readSessionAuthenticated(page, baseUrl) {
-    return await page.evaluate(async (origin) => {
-        const candidates = [
-            `${origin}/api/taskforce/auth/session`,
-            `${origin}/taskforce/api/taskforce/auth/session`
-        ];
-        for (const url of candidates) {
-            try {
-                const response = await fetch(url, {
-                    method: 'GET',
-                    credentials: 'include',
-                    headers: { Accept: 'application/json' }
-                });
-                if (!response.ok) continue;
-                const payload = await response.json().catch(() => ({}));
-                if (payload && typeof payload === 'object' && 'authenticated' in payload) {
-                    return Boolean(payload.authenticated);
-                }
-            } catch {
-                // ignore endpoint miss or cross-origin fetch issues
-            }
-        }
-        return false;
-    }, baseUrl);
-}
-
-async function sessionLooksValid(context, baseUrl) {
-    const page = await context.newPage();
-    try {
-        await page.goto(`${baseUrl}/taskforce/`, { waitUntil: 'domcontentloaded', timeout: 60000 });
-        await page.waitForTimeout(500);
-        if (!/(?:\/taskforce)?\/login(?:\?|$)/i.test(page.url())) {
-            return true;
-        }
-        return await readSessionAuthenticated(page, baseUrl);
-    } catch {
-        return false;
-    } finally {
-        await page.close().catch(() => undefined);
-    }
-}
-
-async function performLogin(context, baseUrl, email, password) {
-    const page = await context.newPage();
-    await page.goto(`${baseUrl}/login?mode=login&next=${encodeURIComponent('/taskforce/')}`, {
-        waitUntil: 'domcontentloaded',
-        timeout: 60000
-    });
-
-    const emailField = page.locator('input[type="email"]').first();
-    const passwordField = page.locator('input[type="password"]').first();
-    const signInButton = page.getByRole('button', { name: /^sign in$/i }).first();
-
-    await emailField.waitFor({ state: 'visible', timeout: 20000 });
-    await passwordField.waitFor({ state: 'visible', timeout: 20000 });
-
-    await emailField.fill(email);
-    await passwordField.fill(password);
-
-    await Promise.all([
-        signInButton.click(),
-        page.waitForLoadState('domcontentloaded').catch(() => undefined)
-    ]);
-
-    await page.waitForFunction(
-        () => !/(?:\/taskforce)?\/login(?:\?|$)/i.test(window.location.pathname + window.location.search),
-        undefined,
-        { timeout: 30000 }
-    ).catch(() => undefined);
-
-    const authenticated = await readSessionAuthenticated(page, baseUrl);
-    if (!authenticated) {
-        const feedback = await page.locator('[class*="loginError"], [data-testid*="login-error"]').first().textContent().catch(() => '');
-        throw new Error(`Login did not produce an authenticated session. url=${page.url()} feedback=${String(feedback || '').trim()}`);
-    }
-
-    await page.goto(`${baseUrl}/taskforce/`, { waitUntil: 'domcontentloaded', timeout: 60000 });
-    await page.close();
-}
-
-async function main() {
-    const baseUrl = resolveBaseUrl();
-    const storageStatePath = resolveStorageStatePath();
-    const { email, password } = resolveCredentials();
-    const forceLogin = /^(1|true|yes)$/i.test(asNonEmpty(process.env.TASKFORCE_PLAYWRIGHT_FORCE_LOGIN));
-
-    await ensureParentDir(storageStatePath);
-
-    const browser = await chromium.launch({ headless: true });
-    try {
-        if (!forceLogin) {
-            try {
-                await fs.access(storageStatePath);
-                const existingContext = await browser.newContext({ storageState: storageStatePath });
-                const existingSessionValid = await sessionLooksValid(existingContext, baseUrl);
-                await existingContext.close();
-                if (existingSessionValid) {
-                    console.log(`Playwright auth session already valid at ${storageStatePath}`);
-                    return;
-                }
-            } catch {
-                // Missing or stale session file; refresh below.
-            }
-        }
-
-        const freshContext = await browser.newContext();
-        await performLogin(freshContext, baseUrl, email, password);
-        await freshContext.storageState({ path: storageStatePath });
-        await freshContext.close();
-        console.log(`Saved Playwright auth session to ${storageStatePath}`);
-    } finally {
-        await browser.close();
-    }
-}
-
-main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-});