@taskforcehq/taskforce 0.3.168

package/dist/hooks/useWorkspaceSyncController.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useWorkspaceSyncController } from './useWorkspaceSyncController';
+vi.mock('../sync/cloudSyncApi', () => ({
+    bootstrapPushWorkspaceSnapshot: vi.fn(),
+    pullWorkspaceChanges: vi.fn(),
+    applyLocalWorkspaceChanges: vi.fn(),
+    handshakeWorkspace: vi.fn(),
+    provisionWorkspace: vi.fn()
+}));
+const makeInput = (overrides = {}) => ({
+    currentWorkspaceId: 'ws-test',
+    setWorkspaceSyncReady: vi.fn(),
+    setWorkspaceCloudHydrated: vi.fn(),
+    setWorkspaceCloudSyncEnabled: vi.fn(),
+    setWorkspaceSyncSourceOfTruth: vi.fn(),
+    setWorkspaceSyncOnboardingCompleted: vi.fn(),
+    setUserGlobalLastSyncedAt: vi.fn(),
+    setWorkspaceLastPullAt: vi.fn(),
+    setWorkspaceLastPushAt: vi.fn(),
+    ...overrides
+});
+describe('useWorkspaceSyncController — tryAcquireWorkspacePullLease', () => {
+    afterEach(() => {
+        localStorage.clear();
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+    });
+    it('returns true when navigator.locks is not available (e.g. SSR or old browser)', async () => {
+        // Simulate environment without locks API
+        vi.stubGlobal('navigator', { locks: undefined });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        let acquired;
+        await act(async () => {
+            acquired = await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(acquired).toBe(true);
+    });
+    it('uses localStorage lease fallback and returns false when another owner holds an active lease', async () => {
+        vi.stubGlobal('navigator', { locks: undefined });
+        const leaseKey = 'taskforce.sync.pullLease.v1.ws-test';
+        window.localStorage.setItem(leaseKey, JSON.stringify({
+            owner: 'other-tab',
+            acquiredAt: Date.now(),
+            expiresAt: Date.now() + 30_000
+        }));
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        let acquired;
+        await act(async () => {
+            acquired = await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(acquired).toBe(false);
+    });
+    it('acquires and releases localStorage lease fallback when locks API is unavailable', async () => {
+        vi.stubGlobal('navigator', { locks: undefined });
+        const leaseKey = 'taskforce.sync.pullLease.v1.ws-test';
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        let acquired;
+        await act(async () => {
+            acquired = await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(acquired).toBe(true);
+        const stored = JSON.parse(String(window.localStorage.getItem(leaseKey) || '{}'));
+        expect(typeof stored.owner).toBe('string');
+        expect(Number(stored.expiresAt)).toBeGreaterThan(Date.now());
+        act(() => {
+            result.current.releaseWorkspacePullLease('ws-test');
+        });
+        expect(window.localStorage.getItem(leaseKey)).toBeNull();
+    });
+    it('returns false when another tab already holds the exclusive lock (cross-tab guard)', async () => {
+        // Simulate navigator.locks.request calling the callback with null (lock unavailable)
+        const mockRequest = vi.fn().mockImplementation((_name, _opts, callback) => {
+            // ifAvailable: true — lock not available, callback receives null
+            const p = Promise.resolve(callback(null));
+            return p;
+        });
+        vi.stubGlobal('navigator', { locks: { request: mockRequest } });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        let acquired;
+        await act(async () => {
+            acquired = await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(acquired).toBe(false);
+        expect(mockRequest).toHaveBeenCalledOnce();
+        expect(mockRequest.mock.calls[0][0]).toBe('taskforce.sync.pullLock.ws-test');
+        expect(mockRequest.mock.calls[0][1]).toMatchObject({ mode: 'exclusive', ifAvailable: true });
+    });
+    it('returns true when the lock is successfully acquired', async () => {
+        // Simulate navigator.locks.request calling the callback with a lock object
+        const mockRequest = vi.fn().mockImplementation((_name, _opts, callback) => {
+            // Call callback with a fake lock object; the callback returns a never-resolving promise
+            // to "hold" the lock — we just need to verify the outer promise resolved true
+            callback({ name: _name });
+            // Return a promise that stays pending (simulating lock held)
+            return new Promise(() => { });
+        });
+        vi.stubGlobal('navigator', { locks: { request: mockRequest } });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        // We need a race because the lock-hold promise never resolves
+        let acquired;
+        await act(async () => {
+            const leasePromise = result.current.tryAcquireWorkspacePullLease('ws-test');
+            // The inner Promise resolves(true) synchronously after callback is invoked
+            acquired = await leasePromise;
+        });
+        expect(acquired).toBe(true);
+        expect(mockRequest).toHaveBeenCalledOnce();
+    });
+    it('returns true on second call when the lock is already held by this tab', async () => {
+        // First call acquires the lock
+        const mockRequest = vi.fn().mockImplementation((_name, _opts, callback) => {
+            callback({ name: _name });
+            return new Promise(() => { });
+        });
+        vi.stubGlobal('navigator', { locks: { request: mockRequest } });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        await act(async () => {
+            await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        // Second call should short-circuit without calling navigator.locks.request again
+        let secondAcquired;
+        await act(async () => {
+            secondAcquired = await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(secondAcquired).toBe(true);
+        // navigator.locks.request should only have been called once (first acquisition)
+        expect(mockRequest).toHaveBeenCalledOnce();
+    });
+    it('does not treat a lock held for one workspace as acquired for another workspace', async () => {
+        const mockRequest = vi.fn()
+            .mockImplementationOnce((_name, _opts, callback) => {
+            callback({ name: _name });
+            return new Promise(() => { });
+        })
+            .mockImplementationOnce((_name, _opts, callback) => {
+            const p = Promise.resolve(callback(null));
+            return p;
+        });
+        vi.stubGlobal('navigator', { locks: { request: mockRequest } });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        let firstAcquired;
+        let secondAcquired;
+        await act(async () => {
+            firstAcquired = await result.current.tryAcquireWorkspacePullLease('ws-a');
+            secondAcquired = await result.current.tryAcquireWorkspacePullLease('ws-b');
+        });
+        expect(firstAcquired).toBe(true);
+        expect(secondAcquired).toBe(false);
+        expect(mockRequest).toHaveBeenCalledTimes(1);
+        expect(mockRequest.mock.calls[0][0]).toBe('taskforce.sync.pullLock.ws-a');
+    });
+    it('releases the lock and allows re-acquisition after releaseWorkspacePullLease', async () => {
+        let resolveHold;
+        const mockRequest = vi.fn().mockImplementation((_name, _opts, callback) => {
+            callback({ name: _name });
+            return new Promise((resolve) => { resolveHold = resolve; });
+        });
+        vi.stubGlobal('navigator', { locks: { request: mockRequest } });
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput()));
+        await act(async () => {
+            await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        // Release the lock
+        act(() => {
+            result.current.releaseWorkspacePullLease('ws-test');
+            resolveHold(); // allow the lock-hold promise to settle
+        });
+        // Now try to acquire again — should call navigator.locks.request a second time
+        await act(async () => {
+            await result.current.tryAcquireWorkspacePullLease('ws-test');
+        });
+        expect(mockRequest).toHaveBeenCalledTimes(2);
+    });
+    it('resets in-flight push/pull refs when workspace changes', async () => {
+        let input = makeInput({ currentWorkspaceId: 'ws-a' });
+        const { result, rerender } = renderHook((props) => useWorkspaceSyncController(props), {
+            initialProps: input
+        });
+        act(() => {
+            result.current.workspacePushInFlightRef.current = true;
+            result.current.workspacePullInFlightRef.current = true;
+        });
+        input = makeInput({ currentWorkspaceId: 'ws-b' });
+        rerender(input);
+        expect(result.current.workspacePushInFlightRef.current).toBe(false);
+        expect(result.current.workspacePullInFlightRef.current).toBe(false);
+    });
+    it('clears same-deadline cooldown when retry timer fires so scheduled pull is not self-blocked', async () => {
+        const { result } = renderHook(() => useWorkspaceSyncController(makeInput({ currentWorkspaceId: 'ws-cooldown' })));
+        const invokePull = vi.fn().mockResolvedValue(true);
+        let scheduledRetryCallback = null;
+        const setTimeoutSpy = vi.spyOn(window, 'setTimeout').mockImplementation(((callback) => {
+            scheduledRetryCallback = callback;
+            return 1;
+        }));
+        const clearTimeoutSpy = vi.spyOn(window, 'clearTimeout').mockImplementation((() => { }));
+        act(() => {
+            result.current.scheduleWorkspacePullRetry(invokePull, { minDelayMs: 250, workspaceId: 'ws-cooldown' });
+        });
+        const cooldownKey = 'taskforce.sync.pullCooldown.v1.ws-cooldown';
+        const before = JSON.parse(String(window.localStorage.getItem(cooldownKey) || '{}'));
+        expect(Number(before.nextAllowedAt)).toBeGreaterThan(Date.now());
+        expect(typeof scheduledRetryCallback).toBe('function');
+        act(() => {
+            scheduledRetryCallback?.();
+        });
+        expect(invokePull).toHaveBeenCalledTimes(1);
+        const after = JSON.parse(String(window.localStorage.getItem(cooldownKey) || '{}'));
+        expect(Number(after.nextAllowedAt)).toBeLessThanOrEqual(Date.now());
+        expect(result.current.isWorkspacePullCooldownActive('ws-cooldown')).toBe(false);
+        setTimeoutSpy.mockRestore();
+        clearTimeoutSpy.mockRestore();
+    });
+    it('keeps recordWorkspaceSyncFailure stable and dispatches to latest onFailureRecorded callback', () => {
+        const firstCallback = vi.fn();
+        let input = makeInput({ onFailureRecorded: firstCallback });
+        const { result, rerender } = renderHook((props) => useWorkspaceSyncController(props), {
+            initialProps: input
+        });
+        const recordBeforeRerender = result.current.recordWorkspaceSyncFailure;
+        act(() => {
+            result.current.recordWorkspaceSyncFailure('pull', 503);
+        });
+        expect(firstCallback).toHaveBeenCalledWith('pull', 503);
+        const secondCallback = vi.fn();
+        input = makeInput({ onFailureRecorded: secondCallback });
+        rerender(input);
+        const recordAfterRerender = result.current.recordWorkspaceSyncFailure;
+        expect(recordAfterRerender).toBe(recordBeforeRerender);
+        act(() => {
+            result.current.recordWorkspaceSyncFailure('handshake', 429);
+        });
+        expect(secondCallback).toHaveBeenCalledWith('handshake', 429);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Taskforce Manager
+ *
+ * A decoupled, reusable collaborative task manager.
+ */
+export { Taskforce } from './Taskforce';
+export { TaskforceCore } from './TaskforceCore';
+export { TaskforceWidget } from './TaskforceWidget';
+export { StandaloneLayout as TaskforceStandaloneLayout } from './components/views/StandaloneLayout';
+export type { TaskforceConfig, TaskItem } from './types';
+export { DEFAULT_CONFIG } from './types';
+export { submitTask, getPendingTasks, clearPendingTasks, exportTasksAsMarkdown, copyTasksToClipboard } from './api';

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * Taskforce Manager
+ *
+ * A decoupled, reusable collaborative task manager.
+ */
+export { Taskforce } from './Taskforce';
+export { TaskforceCore } from './TaskforceCore';
+export { TaskforceWidget } from './TaskforceWidget';
+export { StandaloneLayout as TaskforceStandaloneLayout } from './components/views/StandaloneLayout';
+export { DEFAULT_CONFIG } from './types';
+export { submitTask, getPendingTasks, clearPendingTasks, exportTasksAsMarkdown, copyTasksToClipboard } from './api';

package/dist/localization/index.d.ts

@@ -0,0 +1,8 @@
+export declare const SUPPORTED_LOCALES: readonly ["en-US", "es-419", "pt-BR"];
+export type SupportedLocale = typeof SUPPORTED_LOCALES[number];
+export declare function isSupportedLocale(locale: string): locale is SupportedLocale;
+export declare function getLocale(): SupportedLocale;
+export declare function getSupportedLocales(): SupportedLocale[];
+export declare function setLocale(locale: string): SupportedLocale;
+export declare function initializeLocale(preferredLocale?: string): SupportedLocale;
+export declare function t(key: string, params?: Record<string, string | number>): string;

package/dist/localization/index.js

@@ -0,0 +1,81 @@
+import { enUS } from './locales/en-US';
+import { es419 } from './locales/es-419';
+import { ptBR } from './locales/pt-BR';
+export const SUPPORTED_LOCALES = ['en-US', 'es-419', 'pt-BR'];
+const DEFAULT_LOCALE = 'en-US';
+const CATALOGS = {
+    'en-US': enUS,
+    'es-419': es419,
+    'pt-BR': ptBR
+};
+const BASE_FALLBACK = {
+    en: 'en-US',
+    es: 'es-419',
+    pt: 'pt-BR'
+};
+let currentLocale = DEFAULT_LOCALE;
+function toPathParts(key) {
+    return key.split('.').filter(Boolean);
+}
+function getByPath(source, path) {
+    let cursor = source;
+    for (const part of path) {
+        if (!cursor || typeof cursor !== 'object')
+            return undefined;
+        cursor = cursor[part];
+    }
+    return typeof cursor === 'string' ? cursor : undefined;
+}
+function resolveLocale(input) {
+    if (!input)
+        return DEFAULT_LOCALE;
+    const exact = SUPPORTED_LOCALES.find((locale) => locale.toLowerCase() === input.toLowerCase());
+    if (exact)
+        return exact;
+    const base = input.split('-')[0]?.toLowerCase() || '';
+    return BASE_FALLBACK[base] || DEFAULT_LOCALE;
+}
+function formatTemplate(template, params) {
+    if (!params)
+        return template;
+    return template.replace(/\{([^}]+)\}/g, (_m, key) => {
+        const value = params[key];
+        return value === undefined || value === null ? '' : String(value);
+    });
+}
+export function isSupportedLocale(locale) {
+    return SUPPORTED_LOCALES.includes(locale);
+}
+export function getLocale() {
+    return currentLocale;
+}
+export function getSupportedLocales() {
+    return [...SUPPORTED_LOCALES];
+}
+export function setLocale(locale) {
+    const resolved = resolveLocale(locale);
+    currentLocale = resolved;
+    return resolved;
+}
+export function initializeLocale(preferredLocale) {
+    const fromBrowser = typeof navigator !== 'undefined' ? navigator.language : null;
+    currentLocale = resolveLocale(preferredLocale || fromBrowser);
+    return currentLocale;
+}
+export function t(key, params) {
+    const path = toPathParts(key);
+    const current = getByPath(CATALOGS[currentLocale], path);
+    if (current)
+        return formatTemplate(current, params);
+    const base = currentLocale.split('-')[0]?.toLowerCase() || '';
+    const baseFallback = BASE_FALLBACK[base];
+    if (baseFallback && baseFallback !== currentLocale) {
+        const fromBase = getByPath(CATALOGS[baseFallback], path);
+        if (fromBase)
+            return formatTemplate(fromBase, params);
+    }
+    const fromDefault = getByPath(CATALOGS[DEFAULT_LOCALE], path);
+    if (fromDefault)
+        return formatTemplate(fromDefault, params);
+    return key;
+}

package/dist/localization/locales/en-US.d.ts

@@ -0,0 +1,151 @@
+export interface MessageCatalog {
+    taskForm: {
+        commentsSectionTitle: string;
+        hideComments: string;
+        showComments: string;
+        noComments: string;
+        you: string;
+        commentPlaceholder: string;
+        scheduledLabel: string;
+        dueLabel: string;
+        createdLabel: string;
+        updatedLabel: string;
+        completedLabel: string;
+        emptyValue: string;
+        parentCannotSchedule: string;
+        dueBeforeScheduled: string;
+        overdue: string;
+    };
+    schedule: {
+        completedOnlyPastSchedule: string;
+        noUnscheduledLeafTasks: string;
+    };
+    taskList: {
+        searchPlaceholder: string;
+        clearSearchTitle: string;
+        categoryLabel: string;
+        typeLabel: string;
+        priorityLabel: string;
+        statusLabel: string;
+        assigneeLabel: string;
+        sortByLabel: string;
+        sortCreated: string;
+        sortUpdated: string;
+        sortPriority: string;
+        sortDirectionDescTitle: string;
+        sortDirectionAscTitle: string;
+        resetFiltersTitle: string;
+        archiveAllTitle: string;
+        noTasksToArchiveTitle: string;
+        archiveFinished: string;
+        linksLabel: string;
+        linksAll: string;
+        linksParents: string;
+        linksLinked: string;
+        linksUnlinked: string;
+        includeArchive: string;
+        noMatchingTasks: string;
+        noActiveTasks: string;
+        addTaskToCategoryTitle: string;
+    };
+    actionHeader: {
+        blockedByActiveChildren: string;
+        confirmCascadeComplete: string;
+        confirmCascadeCancel: string;
+        confirmCascadeArchive: string;
+        saveChangesTitle: string;
+        update: string;
+        copyTaskIdTitle: string;
+        startWorking: string;
+        stopWorking: string;
+        unlockAndContinue: string;
+        readyForReview: string;
+        markComplete: string;
+        unmarkComplete: string;
+        cancelTask: string;
+        unmarkCancelled: string;
+        archiveNow: string;
+        completeTaskToArchive: string;
+        clearFormTitle: string;
+        clear: string;
+        addTaskTitle: string;
+        addTask: string;
+    };
+    standalone: {
+        searchPlaceholder: string;
+        clearSearchTitle: string;
+        sortLabel: string;
+        sortCreated: string;
+        sortUpdated: string;
+        sortPriority: string;
+        sortComplexity: string;
+        sortDirectionDescTitle: string;
+        sortDirectionAscTitle: string;
+        groupLabel: string;
+        groupCategory: string;
+        groupType: string;
+        groupPriority: string;
+        groupComplexity: string;
+        groupApproach: string;
+        groupAssignee: string;
+        groupStatus: string;
+        groupHierarchy: string;
+        groupSchedule: string;
+        showEmptyColumns: string;
+        compressEmptyColumns: string;
+        hideEmptyColumns: string;
+        expandCards: string;
+        compressCards: string;
+        exitZenMode: string;
+        enterZenMode: string;
+        toggleFilters: string;
+        addTask: string;
+        helpTutorial: string;
+        settings: string;
+        filtersCaps: string;
+        categoryLabel: string;
+        typeLabel: string;
+        priorityLabel: string;
+        statusLabel: string;
+        assigneeLabel: string;
+        linksLabel: string;
+        chooseLinksTitle: string;
+        linksAll: string;
+        linksParents: string;
+        linksLinked: string;
+        linksUnlinked: string;
+        includeArchiveTitle: string;
+        includeArchive: string;
+        clearFilters: string;
+        noTasksMatchFilters: string;
+        showingWithLinksHint: string;
+        visibleActiveTasksTitle: string;
+        totalActiveTasksTitle: string;
+    };
+    setup: {
+        headingCheckFailed: string;
+        headingGlobalRequired: string;
+        headingWorkspaceRequired: string;
+        subtitleUnreadable: string;
+        subtitleGlobalRequired: string;
+        subtitleWorkspaceRequired: string;
+        runtimeLabel: string;
+        workspaceTermProject: string;
+        workspaceTermMission: string;
+        coreModeOption: string;
+        operationsModeOption: string;
+        workspaceNamePlaceholder: string;
+        workspaceDescriptionPlaceholder: string;
+        saving: string;
+        saveGlobalSetup: string;
+        saveWorkspaceSetup: string;
+        globalSetupSaved: string;
+        workspaceSetupSaved: string;
+        saveFailedWithStatus: string;
+        saveFailed: string;
+        saveWorkspaceFailed: string;
+        retrySetupCheck: string;
+        signOut: string;
+    };
+}
+export declare const enUS: MessageCatalog;

package/dist/localization/locales/en-US.js

@@ -0,0 +1,150 @@
+export const enUS = {
+    taskForm: {
+        commentsSectionTitle: 'Activity & Comments',
+        hideComments: 'Hide Comments',
+        showComments: 'Show Comments',
+        noComments: 'No comments yet. Start the conversation!',
+        you: 'You',
+        commentPlaceholder: 'Type a comment...',
+        scheduledLabel: 'Scheduled:',
+        dueLabel: 'Due:',
+        createdLabel: 'Created:',
+        updatedLabel: 'Updated:',
+        completedLabel: 'Completed:',
+        emptyValue: '—',
+        parentCannotSchedule: 'Parent tasks cannot be scheduled. Schedule leaf tasks instead.',
+        dueBeforeScheduled: 'Due date is before scheduled date.',
+        overdue: 'This task is overdue.'
+    },
+    schedule: {
+        completedOnlyPastSchedule: 'Only completed work can be scheduled in the past.',
+        noUnscheduledLeafTasks: 'No unscheduled leaf tasks found under "{parentTitle}".'
+    },
+    taskList: {
+        searchPlaceholder: 'Search tasks...',
+        clearSearchTitle: 'Clear search',
+        categoryLabel: 'Category',
+        typeLabel: 'Type',
+        priorityLabel: 'Priority',
+        statusLabel: 'Status',
+        assigneeLabel: 'Assignee',
+        sortByLabel: 'Sort By:',
+        sortCreated: 'Created',
+        sortUpdated: 'Updated',
+        sortPriority: 'Priority',
+        sortDirectionDescTitle: 'Sort: Last First',
+        sortDirectionAscTitle: 'Sort: First First',
+        resetFiltersTitle: 'Reset all filters',
+        archiveAllTitle: 'Archive all completed and cancelled tasks',
+        noTasksToArchiveTitle: 'No tasks to archive',
+        archiveFinished: 'Archive Finished',
+        linksLabel: 'Links',
+        linksAll: 'All',
+        linksParents: 'Parents',
+        linksLinked: 'Linked',
+        linksUnlinked: 'Unlinked',
+        includeArchive: 'Include Archive',
+        noMatchingTasks: 'No matching tasks',
+        noActiveTasks: 'No active tasks',
+        addTaskToCategoryTitle: 'Add task to {category}'
+    },
+    actionHeader: {
+        blockedByActiveChildren: 'Complete or cancel all direct child tasks first',
+        confirmCascadeComplete: 'This parent task has {count} active child task(s). Also mark all child tasks as complete?',
+        confirmCascadeCancel: 'This parent task has {count} active child task(s). Also mark all child tasks as cancelled?',
+        confirmCascadeArchive: 'This parent task has {count} child task(s). Also archive all child tasks?',
+        saveChangesTitle: 'Save Changes',
+        update: 'Update',
+        copyTaskIdTitle: 'Click to copy Task ID',
+        startWorking: 'Start Working',
+        stopWorking: 'Stop Working',
+        unlockAndContinue: 'Unlock & Continue Work',
+        readyForReview: 'Ready for Review',
+        markComplete: 'Mark Complete',
+        unmarkComplete: 'Unmark Complete',
+        cancelTask: 'Cancel Task',
+        unmarkCancelled: 'Unmark Cancelled',
+        archiveNow: 'Archive Now',
+        completeTaskToArchive: 'Complete task to archive',
+        clearFormTitle: 'Clear Form',
+        clear: 'Clear',
+        addTaskTitle: 'Add Task',
+        addTask: 'Add Task'
+    },
+    standalone: {
+        searchPlaceholder: 'Search tasks...',
+        clearSearchTitle: 'Clear search',
+        sortLabel: 'Sort:',
+        sortCreated: 'Created',
+        sortUpdated: 'Updated',
+        sortPriority: 'Priority',
+        sortComplexity: 'Complexity',
+        sortDirectionDescTitle: 'Sort: Last First',
+        sortDirectionAscTitle: 'Sort: First First',
+        groupLabel: 'Group:',
+        groupCategory: 'Category',
+        groupType: 'Type',
+        groupPriority: 'Priority',
+        groupComplexity: 'Complexity',
+        groupApproach: 'Approach',
+        groupAssignee: 'Assignee',
+        groupStatus: 'Status',
+        groupHierarchy: 'Hierarchy',
+        groupSchedule: 'Schedule',
+        showEmptyColumns: 'Show Empty Columns',
+        compressEmptyColumns: 'Compress Empty Columns',
+        hideEmptyColumns: 'Hide Empty Columns',
+        expandCards: 'Expand Cards',
+        compressCards: 'Compress Cards',
+        exitZenMode: 'Exit Zen Mode',
+        enterZenMode: 'Enter Zen Mode',
+        toggleFilters: 'Toggle Filters',
+        addTask: 'Add Task',
+        helpTutorial: 'Help / Tutorial',
+        settings: 'Settings',
+        filtersCaps: 'FILTERS:',
+        categoryLabel: 'Category',
+        typeLabel: 'Type',
+        priorityLabel: 'Priority',
+        statusLabel: 'Status',
+        assigneeLabel: 'Assignee',
+        linksLabel: 'Links:',
+        chooseLinksTitle: 'Choose which linked tasks are shown',
+        linksAll: 'All',
+        linksParents: 'Parents',
+        linksLinked: 'Linked',
+        linksUnlinked: 'Unlinked',
+        includeArchiveTitle: 'Include archived tasks',
+        includeArchive: 'Include Archive',
+        clearFilters: 'Clear Filters',
+        noTasksMatchFilters: 'No tasks match current filters.',
+        showingWithLinksHint: 'Showing: {parentFilterLabel}. Switch Links to All or clear filters.',
+        visibleActiveTasksTitle: 'Visible active tasks / total active tasks',
+        totalActiveTasksTitle: 'Total active tasks'
+    },
+    setup: {
+        headingCheckFailed: 'Setup Check Failed',
+        headingGlobalRequired: 'Global Setup Required',
+        headingWorkspaceRequired: 'Workspace Setup Required',
+        subtitleUnreadable: 'Taskforce could not read setup state. Retry to continue.',
+        subtitleGlobalRequired: 'Choose your default operating mode to continue.',
+        subtitleWorkspaceRequired: 'Set up your workspace profile to continue.',
+        runtimeLabel: 'Runtime',
+        workspaceTermProject: 'Project',
+        workspaceTermMission: 'Mission',
+        coreModeOption: 'Core Mode: {workspaceLabel} planning defaults',
+        operationsModeOption: 'Operations Mode: Mission-first terminology and flows',
+        workspaceNamePlaceholder: '{workspaceLabel} name',
+        workspaceDescriptionPlaceholder: '{workspaceLabel} description (optional)',
+        saving: 'Saving...',
+        saveGlobalSetup: 'Save Global Setup',
+        saveWorkspaceSetup: 'Save {workspaceLabel} Setup',
+        globalSetupSaved: 'Global setup saved.',
+        workspaceSetupSaved: '{workspaceLabel} setup saved.',
+        saveFailedWithStatus: 'Failed to save setup ({status})',
+        saveFailed: 'Failed to save setup.',
+        saveWorkspaceFailed: 'Failed to save workspace profile.',
+        retrySetupCheck: 'Retry Setup Check',
+        signOut: 'Sign Out'
+    }
+};

package/dist/localization/locales/es-419.d.ts

@@ -0,0 +1,2 @@
+import type { MessageCatalog } from './en-US';
+export declare const es419: MessageCatalog;