@taskforcehq/taskforce 0.3.168

package/dist/utils/workspaceLifecycle.js

@@ -0,0 +1,69 @@
+export function resolveWorkspaceLifecycleState(input) {
+    const setupState = input.setupState;
+    const runtimeMode = input.runtimeMode;
+    const isAuthenticated = input.isAuthenticated;
+    const cloudRequiresGlobalSetup = Boolean(setupState
+        && runtimeMode === 'cloud'
+        && isAuthenticated
+        && setupState.globalSetupState === 'missing');
+    const localRequiresGlobalSetup = Boolean(setupState
+        && runtimeMode === 'local'
+        && setupState.globalSetupState === 'missing');
+    const cloudRequiresWorkspaceSetup = Boolean(setupState
+        && runtimeMode === 'cloud'
+        && isAuthenticated
+        && setupState.workspaceSetupState === 'missing');
+    const localRequiresWorkspaceSetup = Boolean(setupState
+        && runtimeMode === 'local'
+        && setupState.workspaceSetupState === 'missing');
+    const setupGateActive = Boolean(setupState
+        && (setupState.forceSetup
+            || setupState.forceGlobalSetup
+            || setupState.forceWorkspaceSetup
+            || cloudRequiresGlobalSetup
+            || cloudRequiresWorkspaceSetup
+            || localRequiresGlobalSetup
+            || localRequiresWorkspaceSetup));
+    if (!setupGateActive) {
+        return {
+            setupGateActive: false,
+            needsGlobalSetup: false,
+            needsWorkspaceSetup: false,
+            hasSetupReadError: false,
+            phase: 'ready'
+        };
+    }
+    const shouldForceGlobalSetup = Boolean(setupState
+        && (setupState.forceSetup
+            || setupState.forceGlobalSetup
+            || cloudRequiresGlobalSetup
+            || localRequiresGlobalSetup));
+    const shouldForceWorkspaceSetup = Boolean(setupState
+        && (setupState.forceSetup
+            || setupState.forceWorkspaceSetup
+            || cloudRequiresWorkspaceSetup
+            || localRequiresWorkspaceSetup));
+    const needsGlobalSetup = Boolean(shouldForceGlobalSetup
+        && setupState?.globalSetupState === 'missing');
+    const needsWorkspaceSetup = Boolean(shouldForceWorkspaceSetup
+        && setupState?.workspaceSetupState === 'missing');
+    const hasGlobalSetupUnreadable = Boolean(shouldForceGlobalSetup
+        && setupState?.globalSetupState === 'unreadable');
+    const hasWorkspaceSetupUnreadable = Boolean(shouldForceWorkspaceSetup
+        && setupState?.workspaceSetupState === 'unreadable');
+    const hasSetupReadError = hasGlobalSetupUnreadable || hasWorkspaceSetupUnreadable;
+    const phase = hasSetupReadError
+        ? 'setup-read-error'
+        : needsGlobalSetup
+            ? 'needs-global-setup'
+            : needsWorkspaceSetup
+                ? 'needs-workspace-setup'
+                : 'ready';
+    return {
+        setupGateActive,
+        needsGlobalSetup,
+        needsWorkspaceSetup,
+        hasSetupReadError,
+        phase
+    };
+}

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

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

package/dist/utils/workspaceLifecycle.test.js

@@ -0,0 +1,64 @@
+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/package.json

@@ -0,0 +1,133 @@
+{
+  "name": "@taskforcehq/taskforce",
+  "version": "0.3.168",
+  "description": "Mission Command center for AI-powered task management (beta - under active development)",
+  "author": "Stratnexus <hello@stratnexus.ai> (https://stratnexus.ai)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Stratnexus/taskforce.git"
+  },
+  "homepage": "https://github.com/Stratnexus/taskforce#readme",
+  "bugs": {
+    "url": "https://github.com/Stratnexus/taskforce/issues"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "taskforce": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "src/resources/templates"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./plugins": "./dist/plugins/index.js"
+  },
+  "scripts": {
+    "dev": "sh scripts/run-dev-proxy.sh performance",
+    "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",
+    "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",
+    "mcp": "node dist/mcp/server.js",
+    "gen:workflows": "node scripts/generate-workflow-templates.mjs",
+    "check:workflows": "node scripts/generate-workflow-templates.mjs --check",
+    "db:export:postgres": "node scripts/export-sqlite-to-postgres.mjs",
+    "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",
+    "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: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: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",
+    "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",
+    "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",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^3.6.0",
+    "js-yaml": "^4.1.1",
+    "nodemailer": "^6.10.1",
+    "pg": "^8.18.0",
+    "rehype-sanitize": "^6.0.0",
+    "stripe": "^20.3.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@playwright/test": "^1.58.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.0.10",
+    "@types/react": "^19.2.9",
+    "@types/react-dom": "^19.2.3",
+    "@types/ws": "^8.5.13",
+    "@vitejs/plugin-react": "^5.1.2",
+    "concurrently": "^8.2.2",
+    "html2canvas": "^1.4.1",
+    "jsdom": "^27.4.0",
+    "lucide-react": "^0.474.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^9.1.0",
+    "react-router-dom": "^7.13.0",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "shx": "^0.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
+  }
+}

package/scripts/check-compat-boundaries.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+
+const repoRoot = process.cwd();
+const srcRoot = path.join(repoRoot, 'src');
+const allowedRoots = [
+    path.join(srcRoot, 'migrations'),
+    path.join(srcRoot, 'compat')
+];
+const markerRegex = /COMPAT_REMOVE_AFTER|COMPAT_TRACK/g;
+
+function walk(dir, out = []) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(full, out);
+            continue;
+        }
+        if (entry.isFile() && /\.(ts|tsx|md)$/.test(entry.name)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+
+const files = walk(srcRoot);
+const violations = [];
+
+for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    if (!markerRegex.test(content)) continue;
+
+    const inAllowedRoot = allowedRoots.some(root => file.startsWith(root + path.sep) || file === root);
+    if (!inAllowedRoot) {
+        violations.push(path.relative(repoRoot, file));
+    }
+}
+
+if (violations.length > 0) {
+    console.error('Compatibility markers found outside allowed roots (src/migrations, src/compat):');
+    for (const file of violations) {
+        console.error(`- ${file}`);
+    }
+    process.exit(1);
+}
+
+console.log('Compatibility marker boundary check passed.');

package/scripts/check-env.ts

@@ -0,0 +1,24 @@
+import { assertEnvironment, type EnvValidationTarget } from '../src/config/envSchema.js';
+
+function readArg(name: string): string | null {
+    const prefix = `${name}=`;
+    const found = process.argv.find((arg) => arg.startsWith(prefix));
+    return found ? found.slice(prefix.length) : null;
+}
+
+const targetRaw = (readArg('--target') || process.env.TASKFORCE_ENV_CHECK_TARGET || 'all').trim().toLowerCase();
+const strictRaw = (readArg('--strict') || process.env.TASKFORCE_ENV_CHECK_STRICT || 'true').trim().toLowerCase();
+
+const target: EnvValidationTarget = (targetRaw === 'server' || targetRaw === 'soak' || targetRaw === 'all')
+    ? targetRaw
+    : 'all';
+const strictUnknown = ['1', 'true', 'yes', 'on'].includes(strictRaw);
+
+try {
+    assertEnvironment(process.env, { target, strictUnknown });
+    console.log(`[env] validation passed (target=${target}, strictUnknown=${strictUnknown})`);
+} catch (error) {
+    const message = String((error as Error)?.message || error);
+    console.error(message);
+    process.exit(1);
+}

package/scripts/check-localization-strings.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+const FILES = [
+    'src/components/task/TaskList.tsx',
+    'src/components/task/TaskActionHeader.tsx'
+];
+
+const PATTERNS = [
+    {
+        name: 'attribute string literal',
+        regex: /\b(?:title|placeholder|aria-label)\s*=\s*"[^"]*[A-Za-z][^"]*"/g
+    }
+];
+
+const failures = [];
+
+for (const relPath of FILES) {
+    const filePath = path.join(ROOT, relPath);
+    const source = fs.readFileSync(filePath, 'utf8');
+    const lines = source.split('\n');
+
+    for (const { name, regex } of PATTERNS) {
+        let match;
+        while ((match = regex.exec(source)) !== null) {
+            const start = match.index;
+            const line = source.slice(0, start).split('\n').length;
+            failures.push({
+                file: relPath,
+                line,
+                rule: name,
+                snippet: lines[line - 1]?.trim() || ''
+            });
+        }
+    }
+}
+
+if (failures.length > 0) {
+    console.error('Localization string check failed. Use translation keys via t(...):');
+    for (const failure of failures) {
+        console.error(`- ${failure.file}:${failure.line} [${failure.rule}] ${failure.snippet}`);
+    }
+    process.exit(1);
+}
+
+console.log(`Localization string check passed (${FILES.length} files).`);

package/scripts/check-runtime-boundaries.mjs

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const projectRoot = process.cwd();
+const sourceRoot = path.join(projectRoot, 'src');
+const allowedExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const importPattern = /\bfrom\s+['"]([^'"]+)['"]|\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
+const forbiddenSegments = ['apps/admin', 'apps/site'];
+const violations = [];
+
+function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(fullPath);
+            continue;
+        }
+        if (!allowedExtensions.has(path.extname(entry.name))) continue;
+        const content = fs.readFileSync(fullPath, 'utf8');
+        let match;
+        while ((match = importPattern.exec(content)) !== null) {
+            const specifier = String(match[1] || match[2] || '').trim();
+            if (!specifier) continue;
+            if (!forbiddenSegments.some((segment) => specifier.includes(segment))) continue;
+            violations.push({
+                file: path.relative(projectRoot, fullPath),
+                specifier
+            });
+        }
+    }
+}
+
+walk(sourceRoot);
+
+if (violations.length > 0) {
+    console.error('[runtime-boundaries] Found forbidden cross-surface imports:');
+    for (const violation of violations) {
+        console.error(`- ${violation.file}: ${violation.specifier}`);
+    }
+    process.exit(1);
+}
+
+console.log('[runtime-boundaries] OK');

package/scripts/debug-global.mjs

@@ -0,0 +1,34 @@
+import { TaskforceCore } from '/Users/rossburke/.npm-global/lib/node_modules/taskforce/dist/core/Taskforce.js';
+import path from 'path';
+import fs from 'fs';
+
+const projectRoot = process.cwd();
+console.log('Current Working Directory:', projectRoot);
+
+const core = new TaskforceCore({ projectRoot });
+console.log('Core initialized.');
+console.log('Expected Todo File Path:', core.todoFile);
+
+if (fs.existsSync(core.todoFile)) {
+    console.log('File exists on disk.');
+    const stats = fs.statSync(core.todoFile);
+    console.log('File size:', stats.size);
+} else {
+    console.error('File DOES NOT EXIST at path!');
+}
+
+try {
+    const data = core.listTodos();
+    console.log('Read success!');
+    console.log('Todos found:', data.todos.length);
+    if (data.todos.length > 0) {
+        console.log('First todo ID:', data.todos[0].id);
+        console.log('First todo Title:', data.todos[0].title);
+    }
+    
+    // Check config too
+    const config = core.readConfig();
+    console.log('Config loaded:', Object.keys(config));
+} catch (e) {
+    console.error('Error executing method:', e);
+}

package/scripts/debug-server.mjs

@@ -0,0 +1,36 @@
+
+import { createStandaloneServer } from '/Users/rossburke/.npm-global/lib/node_modules/taskforce/dist/server/index.js';
+import http from 'http';
+
+const projectRoot = process.cwd();
+const PORT = 5177;
+
+console.log('Project Root:', projectRoot);
+
+try {
+    const server = createStandaloneServer({
+        projectRoot,
+        port: PORT
+    });
+
+    server.listen(PORT, async () => {
+        console.log(`Server listening on ${PORT}`);
+
+        const res = await fetch(`http://localhost:${PORT}/api/taskforce/todos`);
+        if (res.ok) {
+            const todos = await res.json();
+            console.log('API Response Status:', res.status);
+            console.log('Todos count from API:', todos.length);
+            if (todos.length > 0) {
+                console.log('First todo:', todos[0].title);
+            }
+        } else {
+            console.error('API Error:', res.status, res.statusText);
+        }
+
+        server.close();
+        process.exit(0);
+    });
+} catch (e) {
+    console.error('Server error:', e);
+}

package/scripts/export-sqlite-to-postgres.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+
+function getArg(name, fallback) {
+    const idx = process.argv.findIndex(a => a === `--${name}`);
+    if (idx >= 0 && process.argv[idx + 1]) return process.argv[idx + 1];
+    return fallback;
+}
+
+function sqlString(value) {
+    if (value === null || value === undefined) return 'NULL';
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function sqlNumber(value) {
+    if (value === null || value === undefined || value === '') return 'NULL';
+    const num = Number(value);
+    return Number.isFinite(num) ? String(num) : 'NULL';
+}
+
+function sqlBool(value) {
+    if (value === null || value === undefined) return 'FALSE';
+    return Number(value) === 1 || value === true ? 'TRUE' : 'FALSE';
+}
+
+const sqlitePath = path.resolve(getArg('sqlite', '.taskforce/taskforce.db'));
+const outPath = path.resolve(getArg('out', '.taskforce/postgres-bootstrap.sql'));
+
+if (!fs.existsSync(sqlitePath)) {
+    console.error(`[Taskforce] SQLite DB not found: ${sqlitePath}`);
+    process.exit(1);
+}
+
+const db = new Database(sqlitePath, { readonly: true });
+
+const tasks = db.prepare('SELECT * FROM tasks ORDER BY id ASC').all();
+const comments = db.prepare('SELECT * FROM comments ORDER BY id ASC').all();
+const screenshots = db.prepare('SELECT * FROM screenshots ORDER BY id ASC').all();
+
+const lines = [];
+lines.push('-- Generated by scripts/export-sqlite-to-postgres.mjs');
+lines.push(`-- Source SQLite: ${sqlitePath}`);
+lines.push(`-- Generated at: ${new Date().toISOString()}`);
+lines.push('-- Apply schema first: src/migrations/postgres/001_init.sql');
+lines.push('BEGIN;');
+lines.push('');
+
+for (const t of tasks) {
+    lines.push(`INSERT INTO tasks (
+  id, tenant_id, title, description, status, priority, complexity, type, category,
+  approach, created_at, updated_at, completed_at, canceled_reason,
+  is_archived, specialists, taxonomies, created_by,
+  scheduled_date, due_date, scheduled_week_key, order_in_day,
+  parent_task_id, child_display_order
+) VALUES (
+  ${sqlString(t.id)}, ${sqlString(t.tenant_id || 'default')}, ${sqlString(t.title)}, ${sqlString(t.description)}, ${sqlString(t.status)}, ${sqlNumber(t.priority)}, ${sqlNumber(t.complexity)}, ${sqlString(t.type)}, ${sqlString(t.category)},
+  ${sqlString(t.approach)}, ${sqlString(t.created_at)}, ${sqlString(t.updated_at)}, ${sqlString(t.completed_at)}, ${sqlString(t.canceled_reason)},
+  ${sqlBool(t.is_archived)}, ${sqlString(t.specialists)}, ${sqlString(t.taxonomies)}, ${sqlString(t.created_by)},
+  ${sqlString(t.scheduled_date)}, ${sqlString(t.due_date)}, ${sqlString(t.scheduled_week_key)}, ${sqlNumber(t.order_in_day)},
+  ${sqlString(t.parent_task_id)}, ${sqlNumber(t.child_display_order)}
+)
+ON CONFLICT (id) DO UPDATE SET
+  title = EXCLUDED.title,
+  description = EXCLUDED.description,
+  status = EXCLUDED.status,
+  priority = EXCLUDED.priority,
+  complexity = EXCLUDED.complexity,
+  type = EXCLUDED.type,
+  category = EXCLUDED.category,
+  approach = EXCLUDED.approach,
+  created_at = EXCLUDED.created_at,
+  updated_at = EXCLUDED.updated_at,
+  completed_at = EXCLUDED.completed_at,
+  canceled_reason = EXCLUDED.canceled_reason,
+  is_archived = EXCLUDED.is_archived,
+  specialists = EXCLUDED.specialists,
+  taxonomies = EXCLUDED.taxonomies,
+  created_by = EXCLUDED.created_by,
+  scheduled_date = EXCLUDED.scheduled_date,
+  due_date = EXCLUDED.due_date,
+  scheduled_week_key = EXCLUDED.scheduled_week_key,
+  order_in_day = EXCLUDED.order_in_day,
+  parent_task_id = EXCLUDED.parent_task_id,
+  child_display_order = EXCLUDED.child_display_order;`);
+}
+
+for (const c of comments) {
+    lines.push(`INSERT INTO comments (id, tenant_id, task_id, text, author, timestamp) VALUES (
+  ${sqlString(c.id)}, ${sqlString(c.tenant_id || 'default')}, ${sqlString(c.task_id)}, ${sqlString(c.text)}, ${sqlString(c.author)}, ${sqlString(c.timestamp)}
+)
+ON CONFLICT (id) DO UPDATE SET
+  tenant_id = EXCLUDED.tenant_id,
+  task_id = EXCLUDED.task_id,
+  text = EXCLUDED.text,
+  author = EXCLUDED.author,
+  timestamp = EXCLUDED.timestamp;`);
+}
+
+for (const s of screenshots) {
+    lines.push(`INSERT INTO screenshots (id, tenant_id, task_id, path, fs_path, caption, timestamp) VALUES (
+  ${sqlString(s.id)}, ${sqlString(s.tenant_id || 'default')}, ${sqlString(s.task_id)}, ${sqlString(s.path)}, ${sqlString(s.fs_path)}, ${sqlString(s.caption)}, ${sqlString(s.timestamp)}
+)
+ON CONFLICT (id) DO UPDATE SET
+  tenant_id = EXCLUDED.tenant_id,
+  task_id = EXCLUDED.task_id,
+  path = EXCLUDED.path,
+  fs_path = EXCLUDED.fs_path,
+  caption = EXCLUDED.caption,
+  timestamp = EXCLUDED.timestamp;`);
+}
+
+lines.push('');
+lines.push('COMMIT;');
+lines.push('');
+
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, `${lines.join('\n')}\n`, 'utf8');
+
+console.log(`[Taskforce] Export complete:`);
+console.log(`  tasks: ${tasks.length}`);
+console.log(`  comments: ${comments.length}`);
+console.log(`  screenshots: ${screenshots.length}`);
+console.log(`  output: ${outPath}`);

package/scripts/generate-env-example.ts

@@ -0,0 +1,8 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { renderEnvExample } from '../src/config/envSchema.js';
+
+const outputPath = path.resolve(process.cwd(), '.env.example');
+const contents = renderEnvExample('all');
+fs.writeFileSync(outputPath, contents, 'utf8');
+console.log(`[env] wrote ${outputPath}`);