@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/utils/taxonomyFormDefaults.test.js

@@ -0,0 +1,63 @@
+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/taxonomyLifecycle.d.ts

@@ -0,0 +1,3 @@
+import type { TaskItem, TaxonomyDefinition } from '../types';
+export declare function taskUsesTaxonomy(task: TaskItem, taxonomyId: string): boolean;
+export declare function getVisibleTaxonomiesForTasks(taxonomies: TaxonomyDefinition[], tasks: TaskItem[]): TaxonomyDefinition[];

package/dist/utils/taxonomyLifecycle.js

@@ -0,0 +1,17 @@
+export function taskUsesTaxonomy(task, taxonomyId) {
+    const taskValue = task.taxonomies?.[taxonomyId];
+    if (taskValue === undefined || taskValue === null || taskValue === '')
+        return false;
+    if (Array.isArray(taskValue)) {
+        return taskValue.some((value) => String(value).trim().length > 0);
+    }
+    return String(taskValue).trim().length > 0;
+}
+export function getVisibleTaxonomiesForTasks(taxonomies, tasks) {
+    const activeTaxonomies = taxonomies.filter((taxonomy) => taxonomy.status !== 'retired');
+    const retiredTaxonomiesInUse = taxonomies.filter((taxonomy) => (taxonomy.status === 'retired' && tasks.some((task) => taskUsesTaxonomy(task, taxonomy.id))));
+    return [
+        ...activeTaxonomies,
+        ...retiredTaxonomiesInUse.filter((taxonomy) => !activeTaxonomies.some((active) => active.id === taxonomy.id))
+    ];
+}

package/dist/utils/taxonomySorting.d.ts

@@ -0,0 +1,7 @@
+import type { TaskItem, TaxonomyDefinition } from '../types';
+export type TaskSortKey = 'created' | 'updated' | 'priority' | 'complexity' | `taxonomy:${string}`;
+export declare function buildCustomTaxonomySortOptions(taxonomies: TaxonomyDefinition[], tasks?: TaskItem[]): Array<{
+    value: TaskSortKey;
+    label: string;
+}>;
+export declare function compareTasksBySortKey(a: TaskItem, b: TaskItem, sortBy: TaskSortKey, sortOrder: 'asc' | 'desc', taxonomies?: TaxonomyDefinition[]): number;

package/dist/utils/taxonomySorting.js

@@ -0,0 +1,74 @@
+import { resolvePriorityValue } from './taskNormalization.js';
+import { getVisibleTaxonomiesForTasks } from './taxonomyLifecycle.js';
+export function buildCustomTaxonomySortOptions(taxonomies, tasks = []) {
+    return getVisibleTaxonomiesForTasks(taxonomies, tasks)
+        .filter((taxonomy) => taxonomy.sortEnabled === true)
+        .map((taxonomy) => ({
+        value: `taxonomy:${taxonomy.id}`,
+        label: taxonomy.status === 'retired' ? `${taxonomy.label} (Retired)` : taxonomy.label
+    }));
+}
+function getTaxonomyOptionRank(task, taxonomy) {
+    const taskValue = task.taxonomies?.[taxonomy.id];
+    if (taskValue === undefined || taskValue === null || taskValue === '')
+        return null;
+    const selectedValues = Array.isArray(taskValue)
+        ? taskValue.map((value) => String(value))
+        : [String(taskValue)];
+    for (let index = 0; index < taxonomy.options.length; index += 1) {
+        if (selectedValues.includes(String(taxonomy.options[index]?.value))) {
+            return index;
+        }
+    }
+    return null;
+}
+function compareCreatedAtDesc(a, b) {
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+}
+export function compareTasksBySortKey(a, b, sortBy, sortOrder, taxonomies = []) {
+    let comparison = 0;
+    if (sortBy === 'created') {
+        comparison = compareCreatedAtDesc(a, b);
+        return sortOrder === 'desc' ? comparison : -comparison;
+    }
+    if (sortBy === 'updated') {
+        const aUpdated = a.updatedAt || a.createdAt;
+        const bUpdated = b.updatedAt || b.createdAt;
+        comparison = new Date(bUpdated).getTime() - new Date(aUpdated).getTime();
+        return sortOrder === 'desc' ? comparison : -comparison;
+    }
+    if (sortBy === 'priority') {
+        const weightA = resolvePriorityValue(a.priority);
+        const weightB = resolvePriorityValue(b.priority);
+        comparison = weightA !== weightB ? weightB - weightA : compareCreatedAtDesc(a, b);
+        return sortOrder === 'desc' ? comparison : -comparison;
+    }
+    if (sortBy === 'complexity') {
+        const complexityA = typeof a.complexity === 'number' ? a.complexity : 3;
+        const complexityB = typeof b.complexity === 'number' ? b.complexity : 3;
+        comparison = complexityA !== complexityB ? complexityB - complexityA : compareCreatedAtDesc(a, b);
+        return sortOrder === 'desc' ? comparison : -comparison;
+    }
+    if (sortBy.startsWith('taxonomy:')) {
+        const taxonomyId = sortBy.slice('taxonomy:'.length);
+        const taxonomy = taxonomies.find((candidate) => candidate.id === taxonomyId);
+        if (!taxonomy) {
+            comparison = compareCreatedAtDesc(a, b);
+            return sortOrder === 'desc' ? comparison : -comparison;
+        }
+        const rankA = getTaxonomyOptionRank(a, taxonomy);
+        const rankB = getTaxonomyOptionRank(b, taxonomy);
+        if (rankA === null && rankB === null)
+            return compareCreatedAtDesc(a, b);
+        if (rankA === null)
+            return 1;
+        if (rankB === null)
+            return -1;
+        if (rankA !== rankB) {
+            return sortOrder === 'desc' ? rankB - rankA : rankA - rankB;
+        }
+        return compareCreatedAtDesc(a, b);
+    }
+    comparison = compareCreatedAtDesc(a, b);
+    return sortOrder === 'desc' ? comparison : -comparison;
+}

package/dist/utils/theme.d.ts

@@ -0,0 +1,15 @@
+export declare const TASKFORCE_THEME_IDS: readonly ["light", "dawn", "dark", "midnight"];
+export type TaskforceTheme = typeof TASKFORCE_THEME_IDS[number];
+export type TaskforceThemeFamily = 'light' | 'dark';
+export type TaskforceThemeIcon = 'sun' | 'wind' | 'moon' | 'sparkles';
+export interface TaskforceThemeOption {
+    id: TaskforceTheme;
+    label: string;
+    family: TaskforceThemeFamily;
+    icon: TaskforceThemeIcon;
+}
+export declare const DEFAULT_TASKFORCE_THEME: TaskforceTheme;
+export declare const TASKFORCE_THEME_OPTIONS: readonly TaskforceThemeOption[];
+export declare function isTaskforceTheme(value: unknown): value is TaskforceTheme;
+export declare function normalizeTaskforceTheme(value: unknown): TaskforceTheme | null;
+export declare function isLightThemeFamily(theme: TaskforceTheme | string | null | undefined): boolean;

package/dist/utils/theme.js

@@ -0,0 +1,23 @@
+export const TASKFORCE_THEME_IDS = ['light', 'dawn', 'dark', 'midnight'];
+export const DEFAULT_TASKFORCE_THEME = 'dark';
+export const TASKFORCE_THEME_OPTIONS = [
+    { id: 'light', label: 'Light', family: 'light', icon: 'sun' },
+    { id: 'dawn', label: 'Dawn', family: 'light', icon: 'wind' },
+    { id: 'dark', label: 'Dark', family: 'dark', icon: 'moon' },
+    { id: 'midnight', label: 'Midnight', family: 'dark', icon: 'sparkles' },
+];
+const TASKFORCE_THEME_SET = new Set(TASKFORCE_THEME_IDS);
+const LIGHT_THEME_FAMILY_SET = new Set(TASKFORCE_THEME_OPTIONS.filter((option) => option.family === 'light').map((option) => option.id));
+export function isTaskforceTheme(value) {
+    return typeof value === 'string' && TASKFORCE_THEME_SET.has(value);
+}
+export function normalizeTaskforceTheme(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return isTaskforceTheme(normalized) ? normalized : null;
+}
+export function isLightThemeFamily(theme) {
+    const normalized = normalizeTaskforceTheme(theme);
+    return normalized !== null && LIGHT_THEME_FAMILY_SET.has(normalized);
+}

package/dist/utils/uiNotice.d.ts

@@ -0,0 +1,7 @@
+export type UiNoticeTone = 'success' | 'error' | 'info';
+export interface UiNotice {
+    message: string;
+    tone: UiNoticeTone;
+    ttlMs?: number;
+}
+export declare function resolveUiNoticeTtl(tone: UiNoticeTone, ttlMs?: number): number;

package/dist/utils/uiNotice.js

@@ -0,0 +1,6 @@
+export function resolveUiNoticeTtl(tone, ttlMs) {
+    if (typeof ttlMs === 'number' && Number.isFinite(ttlMs) && ttlMs > 0) {
+        return ttlMs;
+    }
+    return tone === 'error' ? 3600 : 2600;
+}

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

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

package/dist/utils/uiNotice.test.js

@@ -0,0 +1,18 @@
+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.d.ts

@@ -4,5 +4,19 @@ export declare function generateWorkspaceId(): string;
 export declare function normalizeWorkspaceStorageScope(scopeRaw?: string): string;
 export declare function normalizeWorkspaceStorageScopeLegacy(scopeRaw?: string): string;
 export declare function resolveWorkspaceStorageScopeFromProjectRoot(projectRoot?: string): string;
+export declare function resolveWorkspaceSelectionScopeForRuntime(input: {
+    projectRoot?: string;
+    runtimeMode?: 'local' | 'cloud';
+}): string;
+export declare function resolveWorkspaceUiStateScopeForRuntime(input: {
+    projectRoot?: string;
+    runtimeMode?: 'local' | 'cloud';
+    workspaceId?: string;
+}): string;
+export declare function resolveWorkspaceStorageScopeForRuntime(input: {
+    projectRoot?: string;
+    runtimeMode?: 'local' | 'cloud';
+    workspaceId?: string;
+}): string;
 export declare function isReservedWorkspaceId(workspaceId: string): boolean;
 export declare function isUsableWorkspaceId(workspaceId: string): boolean;

package/dist/utils/workspaceIdentity.js

@@ -38,6 +38,27 @@ export function resolveWorkspaceStorageScopeFromProjectRoot(projectRoot) {
         return WORKSPACE_BOOTSTRAP_SCOPE;
     return normalizeWorkspaceStorageScope(raw);
 }
+export function resolveWorkspaceSelectionScopeForRuntime(input) {
+    const runtimeMode = input.runtimeMode === 'cloud' ? 'cloud' : 'local';
+    if (runtimeMode === 'cloud') {
+        return WORKSPACE_BOOTSTRAP_SCOPE;
+    }
+    return resolveWorkspaceStorageScopeFromProjectRoot(input.projectRoot);
+}
+export function resolveWorkspaceUiStateScopeForRuntime(input) {
+    const runtimeMode = input.runtimeMode === 'cloud' ? 'cloud' : 'local';
+    if (runtimeMode === 'cloud') {
+        const workspaceId = String(input.workspaceId || '').trim();
+        if (workspaceId && !isReservedWorkspaceId(workspaceId)) {
+            return normalizeWorkspaceStorageScope(`cloud-workspace:${workspaceId}`);
+        }
+        return WORKSPACE_BOOTSTRAP_SCOPE;
+    }
+    return resolveWorkspaceStorageScopeFromProjectRoot(input.projectRoot);
+}
+export function resolveWorkspaceStorageScopeForRuntime(input) {
+    return resolveWorkspaceUiStateScopeForRuntime(input);
+}
 export function isReservedWorkspaceId(workspaceId) {
     return String(workspaceId || '').trim().toLowerCase() === RESERVED_WORKSPACE_ID;
 }

package/dist/utils/workspaceIdentity.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { RESERVED_WORKSPACE_ID, WORKSPACE_BOOTSTRAP_SCOPE, generateWorkspaceId, isReservedWorkspaceId, isUsableWorkspaceId, normalizeWorkspaceStorageScopeLegacy, normalizeWorkspaceStorageScope, resolveWorkspaceStorageScopeFromProjectRoot } from './workspaceIdentity';
+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);
@@ -10,6 +10,35 @@ describe('workspace identity invariants', () => {
         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');
     });

package/dist/utils/workspaceSyncPresentation.d.ts

@@ -0,0 +1,20 @@
+export type HeaderWorkspaceSyncStatus = 'off' | 'syncing' | 'attention' | 'healthy';
+interface ResolveHeaderWorkspaceSyncPresentationInput {
+    runtimeMode: 'local' | 'cloud';
+    isAuthenticated: boolean;
+    workspaceSyncStatus: HeaderWorkspaceSyncStatus;
+    workspaceCloudSyncEnabled: boolean;
+    workspaceSyncSummary: string;
+    workspaceSyncRecommendedAction: string;
+    workspaceSyncError: string;
+}
+export interface HeaderWorkspaceSyncPresentation {
+    actionable: boolean;
+    status: HeaderWorkspaceSyncStatus;
+    syncEnabledLabel: string;
+    summary: string;
+    recommendedAction: string;
+    lastError: string;
+}
+export declare function resolveHeaderWorkspaceSyncPresentation(input: ResolveHeaderWorkspaceSyncPresentationInput): HeaderWorkspaceSyncPresentation;
+export {};

package/dist/utils/workspaceSyncPresentation.js

@@ -0,0 +1,21 @@
+export function resolveHeaderWorkspaceSyncPresentation(input) {
+    const actionable = input.runtimeMode === 'local' && input.isAuthenticated;
+    if (actionable) {
+        return {
+            actionable,
+            status: input.workspaceSyncStatus,
+            syncEnabledLabel: input.workspaceCloudSyncEnabled ? 'yes' : 'no',
+            summary: input.workspaceSyncSummary,
+            recommendedAction: input.workspaceSyncRecommendedAction,
+            lastError: input.workspaceSyncError
+        };
+    }
+    return {
+        actionable,
+        status: 'off',
+        syncEnabledLabel: 'no',
+        summary: 'Sign in to enable workspace sync controls on this device.',
+        recommendedAction: 'Sign in to manage workspace sync for this workspace.',
+        lastError: 'Sign in to enable workspace sync controls on this device.'
+    };
+}

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

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

package/dist/utils/workspaceSyncPresentation.test.js

@@ -0,0 +1,36 @@
+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'
+        });
+        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');
+    });
+});

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@taskforcehq/taskforce",
-  "version": "0.3.170",
+  "version": "0.3.301",
   "description": "Mission Command center for AI-powered task management (beta - under active development)",
-  "author": "Stratnexus <hello@stratnexus.ai> (https://stratnexus.ai)",
+  "author": "Taskforce HQ <hello@taskforcehq.ai> (https://taskforcehq.ai)",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Stratnexus/taskforce.git"
+    "url": "git+https://github.com/taskforcehq/taskforce.git"
   },
-  "homepage": "https://github.com/Stratnexus/taskforce#readme",
+  "homepage": "https://github.com/taskforcehq/taskforce#readme",
   "bugs": {
-    "url": "https://github.com/Stratnexus/taskforce/issues"
+    "url": "https://github.com/taskforcehq/taskforce/issues"
   },
   "publishConfig": {
     "access": "restricted",
@@ -33,26 +33,26 @@
     "./plugins": "./dist/plugins/index.js"
   },
   "scripts": {
-    "dev": "sh scripts/run-dev-proxy.sh performance",
+    "dev": "concurrently \"sh scripts/run-dev-proxy.sh performance\" \"TASKFORCE_CLOUD_ENVIRONMENT=performance npm run dev:site\" \"npm run dev:admin\"",
     "perf": "sh scripts/run-dev-proxy.sh performance",
     "stage": "sh scripts/run-dev-proxy.sh staging",
-    "performance": "npm run perf",
-    "staging": "npm run stage",
-    "prod": "VITE_TASKFORCE_BASE_URL=https://app.taskforcehq.ai npm run dev:runtime",
-    "dev:runtime": "concurrently \"npm run dev:app\" \"TASKFORCE_GIT_BACKUP=true node --import tsx src/cli.ts open 5174\"",
-    "stage:direct": "VITE_TASKFORCE_BASE_URL=https://staging-app.taskforcehq.ai npm run dev:runtime",
-    "perf:direct": "VITE_TASKFORCE_BASE_URL=https://performance-app.taskforcehq.ai npm run dev:runtime",
-    "dev:setup:force": "concurrently \"npm run dev:app\" \"TASKFORCE_GIT_BACKUP=true TASKFORCE_FORCE_SETUP=true node --import tsx src/cli.ts open 5175\"",
-    "dev:setup:force-global": "concurrently \"npm run dev:app\" \"TASKFORCE_GIT_BACKUP=true TASKFORCE_FORCE_GLOBAL_SETUP=true node --import tsx src/cli.ts open 5176\"",
-    "dev:setup:force-workspace": "concurrently \"npm run dev:app\" \"TASKFORCE_GIT_BACKUP=true TASKFORCE_FORCE_WORKSPACE_SETUP=true node --import tsx src/cli.ts open 5177\"",
-    "dev:app": "vite build --config vite.config.standalone.ts --watch",
-    "dev:site": "vite --config vite.config.site.ts --port 4173",
-    "dev:admin": "vite --config vite.config.admin.ts --port 5181",
+    "prod": "TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=production TASKFORCE_CLOUD_PROXY_BASE_URL=https://app.taskforcehq.ai VITE_TASKFORCE_BASE_URL=https://app.taskforcehq.ai npm run dev:runtime",
+    "dev:runtime": "concurrently \"npm run dev:app\" \"TASKFORCE_RUNTIME_MODE=local sh scripts/with-esbuild.sh node --import tsx src/cli.ts open 5174\"",
+    "stage:direct": "TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=staging TASKFORCE_CLOUD_PROXY_BASE_URL=https://staging-app.taskforcehq.ai VITE_TASKFORCE_BASE_URL=https://staging-app.taskforcehq.ai npm run dev:runtime",
+    "perf:direct": "TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=performance TASKFORCE_CLOUD_PROXY_BASE_URL=https://performance-app.taskforcehq.ai VITE_TASKFORCE_BASE_URL=https://performance-app.taskforcehq.ai npm run dev:runtime",
+    "dev:setup:force": "concurrently \"npm run dev:app\" \"TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=production TASKFORCE_FORCE_SETUP=true node --import tsx src/cli.ts open 5175\"",
+    "dev:setup:force-global": "concurrently \"npm run dev:app\" \"TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=production TASKFORCE_FORCE_GLOBAL_SETUP=true node --import tsx src/cli.ts open 5176\"",
+    "dev:setup:force-workspace": "concurrently \"npm run dev:app\" \"TASKFORCE_RUNTIME_MODE=local TASKFORCE_CLOUD_ENVIRONMENT=production TASKFORCE_FORCE_WORKSPACE_SETUP=true node --import tsx src/cli.ts open 5177\"",
+    "dev:app": "sh scripts/with-esbuild.sh vite build --config vite.config.standalone.ts --watch",
+    "dev:site": "sh scripts/with-esbuild.sh vite --config vite.config.site.ts --port 4173",
+    "dev:admin": "sh scripts/with-esbuild.sh vite --config vite.config.admin.ts --port 5181",
     "build:site": "vite build --config vite.config.site.ts",
     "build:admin": "vite build --config vite.config.admin.ts",
     "build:app": "vite build --config vite.config.standalone.ts",
     "build:ui": "npm run build:app",
-    "build": "npm run gen:workflows && shx rm -rf dist && tsc && shx cp src/Taskforce.module.css dist/Taskforce.module.css && shx mkdir -p dist/resources && shx cp -r src/resources/* dist/resources/ && shx rm -f dist/resources/templates/workflows/release.yaml && shx mkdir -p dist/public && shx cp -r src/assets/images/* dist/public/ && shx cp -r src/assets/favicon/* dist/public/ && shx chmod +x dist/cli.js && npm run build:ui",
+    "check:deploy-preflight": "npm run build",
+    "hooks:install": "git config core.hooksPath .githooks",
+    "build": "shx rm -rf dist && tsc && shx cp src/Taskforce.module.css dist/Taskforce.module.css && shx mkdir -p dist/resources && shx cp -r src/resources/* dist/resources/ && shx rm -f dist/resources/templates/workflows/release.yaml && shx mkdir -p dist/public && shx cp -r src/assets/images/* dist/public/ && shx cp -r src/assets/favicon/* dist/public/ && shx chmod +x dist/cli.js && npm run build:ui",
     "mcp": "node dist/mcp/server.js",
     "gen:workflows": "node scripts/generate-workflow-templates.mjs",
     "check:workflows": "node scripts/generate-workflow-templates.mjs --check",
@@ -60,27 +60,34 @@
     "check:localization-strings": "node scripts/check-localization-strings.mjs",
     "version:next": "node scripts/release-version.mjs --dry-run",
     "version:bump": "node scripts/release-version.mjs",
+    "deploy:staging": "bash scripts/deploy-staging.sh",
+    "deploy:prod": "bash scripts/deploy-prod.sh",
     "test:localization": "vitest run src/__tests__/localizationCatalogs.test.ts",
     "check:runtime-boundaries": "node scripts/check-runtime-boundaries.mjs",
     "test:workflow-readiness": "npm run check:workflows && vitest src/__tests__/workflowSimulation.test.ts src/__tests__/workflowExportMatrix.test.ts src/__tests__/workflowExportSnapshots.test.ts src/__tests__/workflowDocumentFixtures.test.ts src/__tests__/structuredCommentValidation.test.ts src/__tests__/structuredDocValidation.test.ts src/__tests__/workflowV2Policy.test.ts src/__tests__/workflowGeneration.test.ts src/__tests__/templates.test.ts",
     "test": "vitest",
+    "test:ci": "vitest run --maxWorkers=1",
     "test:soak": "sh scripts/run-soak.sh",
     "test:soak:smoke": "SYNC_SOAK_PROFILE=smoke sh scripts/run-soak.sh",
     "test:soak:stress": "SYNC_SOAK_PROFILE=stress sh scripts/run-soak.sh",
     "test:soak:overnight": "SYNC_SOAK_PROFILE=overnight sh scripts/run-soak.sh",
     "test:e2e:realtime": "sh scripts/run-e2e-realtime.sh",
+    "test:e2e:realtime:release": "npm run test:e2e:realtime -- tests/e2e/attachment-sync.spec.ts tests/e2e/realtime-multiclient.spec.ts tests/e2e/realtime-reconnect.spec.ts",
+    "test:e2e:realtime:attachments": "npm run test:e2e:realtime -- tests/e2e/attachment-sync.spec.ts",
     "test:e2e:realtime:multiclient": "npm run test:e2e:realtime -- tests/e2e/realtime-multiclient.spec.ts",
     "test:e2e:realtime:reconnect": "npm run test:e2e:realtime -- tests/e2e/realtime-reconnect.spec.ts",
+    "playwright:auth:bootstrap": "node scripts/bootstrap-playwright-auth.mjs",
+    "playwright:auth": "sh scripts/playwright-auth.sh",
     "check:env": "node --import tsx scripts/check-env.ts --target=server --strict=true",
     "check:env:soak": "node --import tsx scripts/check-env.ts --target=soak --strict=true",
+    "check:compat": "node scripts/check-compat-boundaries.mjs",
     "gen:env-example": "node --import tsx scripts/generate-env-example.ts",
     "check:sync-smoke-preflight": "node --import tsx src/soak/preflight.cli.ts",
-    "check:compat": "node scripts/check-compat-boundaries.js",
-    "test:migration-gate": "npx tsc --noEmit && npm run check:compat && npx vitest run src/hooks/useTaskforce.priority-filters.test.ts src/TaskforceCore.test.tsx",
     "test:auth-runtime-guard": "npx vitest run src/shared/runtimeContract.test.ts src/server/index.cookieProxy.test.ts src/server/routes.test.ts src/TaskforceCore.test.tsx",
-    "test:global": "node scripts/test-global.js",
+    "test:migration-gate": "npm run check:compat && npx vitest run src/config/deployment.test.ts",
+    "install:global": "node scripts/test-global.js",
     "prepublishOnly": "npm run build",
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/postinstall.js || true"
   },
   "peerDependencies": {
     "react": ">=18.0.0",