@taskforcehq/taskforce 0.3.302 → 0.3.303

package/dist/mcp/runtime.js

@@ -1664,7 +1664,7 @@ export function createTaskforceMcpServer(options = {}) {
             console.error(`[Taskforce MCP] Failed to send resources/updated for ${uri}: ${error.message}`);
         }
     }
-    async function notifyResourceMutation(options) {
+    function collectResourceMutationUris(options) {
         const uris = new Set();
         if (options.includeConfig)
             uris.add(RESOURCE_CONFIG_URI);
@@ -1691,10 +1691,39 @@ export function createTaskforceMcpServer(options = {}) {
                 uris.add(workstreamUriFor(workstreamId));
             }
         }
+        return uris;
+    }
+    const pendingResourceInvalidations = new Set();
+    let resourceInvalidationFlushHandle = null;
+    function scheduleResourceInvalidationFlush() {
+        if (resourceInvalidationFlushHandle)
+            return;
+        resourceInvalidationFlushHandle = setTimeout(() => {
+            resourceInvalidationFlushHandle = null;
+            void flushScheduledResourceInvalidations();
+        }, 0);
+    }
+    async function flushScheduledResourceInvalidations() {
+        if (pendingResourceInvalidations.size === 0)
+            return;
+        const uris = Array.from(pendingResourceInvalidations);
+        pendingResourceInvalidations.clear();
         for (const uri of uris) {
             await notifyResourceUpdatedIfSubscribed(uri);
         }
     }
+    function scheduleResourceMutation(options) {
+        const uris = collectResourceMutationUris(options);
+        if (uris.size === 0)
+            return;
+        for (const uri of uris) {
+            pendingResourceInvalidations.add(uri);
+        }
+        scheduleResourceInvalidationFlush();
+    }
+    async function notifyResourceMutation(options) {
+        scheduleResourceMutation(options);
+    }
     function buildConfigResourcePayload() {
         return {
             project: {
@@ -1716,13 +1745,26 @@ export function createTaskforceMcpServer(options = {}) {
         };
     }
     function buildTasksResourcePayload() {
-        const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks;
+        const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks
+            .map((task) => buildPlanningTaskSummary(task));
         return {
             total: tasks.length,
             tasks,
         };
     }
-    function listHistoricalWorkspaceTasks() {
+    function buildPlanningTaskSummary(task) {
+        const { description, comments, taskEvents, activity, createdByActor, assigneeActor, attachments, checklistItems, ...rest } = task;
+        return rest;
+    }
+    function buildPlanningWorkstreamSummary(workstream) {
+        const { description, taskIds, ...rest } = workstream;
+        return rest;
+    }
+    function buildPlanningInitiativeSummary(initiative) {
+        const { description, ...rest } = initiative;
+        return rest;
+    }
+    function buildHistoricalWorkspaceTaskSnapshot() {
         const activeTasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks;
         const archivedTasks = core.listArchive(ACTIVE_WORKSPACE_ID).archived;
         const byId = new Map();
@@ -1730,40 +1772,70 @@ export function createTaskforceMcpServer(options = {}) {
             byId.set(task.id, task);
         for (const task of archivedTasks)
             byId.set(task.id, task);
-        return Array.from(byId.values());
+        const tasks = Array.from(byId.values());
+        const tasksByWorkstreamId = new Map();
+        for (const task of tasks) {
+            const normalizedWorkstreamId = String(task.workstreamId || '').trim();
+            if (!normalizedWorkstreamId)
+                continue;
+            const current = tasksByWorkstreamId.get(normalizedWorkstreamId) || [];
+            current.push(buildPlanningTaskSummary(task));
+            tasksByWorkstreamId.set(normalizedWorkstreamId, current);
+        }
+        return {
+            tasks,
+            tasksByWorkstreamId,
+        };
     }
-    function buildInitiativeResourcePayload(initiative) {
-        const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID)
-            .filter((workstream) => workstream.initiativeId === initiative.id);
-        const tasks = listHistoricalWorkspaceTasks()
-            .filter((task) => workstreams.some((workstream) => workstream.id === task.workstreamId));
+    function buildInitiativeResourcePayload(initiative, options) {
+        const tasksByWorkstreamId = options?.tasksByWorkstreamId || buildHistoricalWorkspaceTaskSnapshot().tasksByWorkstreamId;
+        const workstreams = options?.workstreamsByInitiativeId?.get(initiative.id)
+            || core.listWorkstreams(ACTIVE_WORKSPACE_ID)
+                .filter((workstream) => workstream.initiativeId === initiative.id);
+        const tasks = workstreams.flatMap((workstream) => tasksByWorkstreamId.get(workstream.id) || []);
         return {
-            initiative,
+            initiative: buildPlanningInitiativeSummary(initiative),
             workstreamCount: workstreams.length,
             taskCount: tasks.length,
-            workstreams,
+            workstreams: workstreams.map((workstream) => buildPlanningWorkstreamSummary(workstream)),
         };
     }
-    function buildWorkstreamResourcePayload(workstream) {
-        const tasks = listHistoricalWorkspaceTasks()
-            .filter((task) => task.workstreamId === workstream.id);
+    function buildWorkstreamResourcePayload(workstream, options) {
+        const tasksByWorkstreamId = options?.tasksByWorkstreamId || buildHistoricalWorkspaceTaskSnapshot().tasksByWorkstreamId;
+        const tasks = tasksByWorkstreamId.get(workstream.id)
+            || [];
         return {
-            workstream,
+            workstream: buildPlanningWorkstreamSummary(workstream),
             taskCount: tasks.length,
             tasks,
         };
     }
     function buildInitiativesResourcePayload() {
+        const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID);
+        const workstreamsByInitiativeId = new Map();
+        for (const workstream of workstreams) {
+            const normalizedInitiativeId = String(workstream.initiativeId || '').trim();
+            if (!normalizedInitiativeId)
+                continue;
+            const current = workstreamsByInitiativeId.get(normalizedInitiativeId) || [];
+            current.push(workstream);
+            workstreamsByInitiativeId.set(normalizedInitiativeId, current);
+        }
+        const { tasksByWorkstreamId } = buildHistoricalWorkspaceTaskSnapshot();
         const initiatives = core.listInitiatives(ACTIVE_WORKSPACE_ID)
-            .map((initiative) => buildInitiativeResourcePayload(initiative));
+            .map((initiative) => buildInitiativeResourcePayload(initiative, {
+            workstreamsByInitiativeId,
+            tasksByWorkstreamId,
+        }));
         return {
             total: initiatives.length,
             initiatives,
         };
     }
     function buildWorkstreamsResourcePayload() {
+        const { tasksByWorkstreamId } = buildHistoricalWorkspaceTaskSnapshot();
         const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID)
-            .map((workstream) => buildWorkstreamResourcePayload(workstream));
+            .map((workstream) => buildWorkstreamResourcePayload(workstream, { tasksByWorkstreamId }));
         return {
             total: workstreams.length,
             workstreams,
@@ -3230,18 +3302,7 @@ export function createTaskforceMcpServer(options = {}) {
                     }
                 }
             };
-        }).filter((tool) => {
-            if (!hasPermission(TOOL_PERMISSIONS[tool.name]))
-                return false;
-            const taskforceToolsEnv = process.env.TASKFORCE_TOOLS;
-            if (taskforceToolsEnv) {
-                const enabledTools = taskforceToolsEnv.split(',').map(t => t.trim()).filter(Boolean);
-                if (enabledTools.length > 0 && !enabledTools.includes(tool.name)) {
-                    return false;
-                }
-            }
-            return true;
-        });
+        }).filter((tool) => hasPermission(TOOL_PERMISSIONS[tool.name]));
         return {
             tools,
         };

package/dist/mcp/runtime.test.js

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -7,61 +7,8 @@ import { MCP_TOOL_REGISTRY } from './toolRegistry';
 import { TaskforceCore, TaskforceRuleError } from '../core/Taskforce';
 import { WorkspaceAssetStore } from '../storage/workspaceAssetStore';
 import { ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, APP_GATE_DEFINITIONS, } from '../runtime/appGates';
-function createProjectRoot() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-runtime-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    try {
-        Object.defineProperty(core, 'getAccountAccessStatus', {
-            configurable: true,
-            value: () => ({
-                gate: 'ok',
-                hasEntitlement: true,
-                canAccessApp: true,
-                canAccessPlans: true,
-                signupMonetizationStrategy: 'none',
-                planSelectionRequired: false,
-                message: null,
-                entitlement: null
-            })
-        });
-        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
-        core.ensureBootstrapUserAccess({
-            userId: 'owner-1',
-            workspaceId: 'workspace-1',
-            role: 'owner',
-            email: 'owner-1@example.com'
-        });
-    }
-    finally {
-        core.close();
-    }
-    return projectRoot;
-}
-async function listTools(projectRoot, runtimeMode) {
-    const runtime = createTaskforceMcpServer({
-        projectRoot,
-        runtimeMode,
-        logStartup: false,
-        auth: runtimeMode === 'cloud'
-            ? { scopes: ['tasks:read', 'tasks:write', 'workspace:read'] }
-            : undefined
-    });
-    const handler = runtime.server._requestHandlers.get('tools/list');
-    if (!handler) {
-        throw new Error('tools/list handler not registered');
-    }
-    return await handler({
-        jsonrpc: '2.0',
-        id: 'test-tools-list',
-        method: 'tools/list',
-        params: {}
-    }, {});
-}
-async function callTool(projectRoot, runtimeMode, name, args, options) {
-    const runtime = createTaskforceMcpServer({
+function createRuntime(projectRoot, runtimeMode, options) {
+    return createTaskforceMcpServer({
         projectRoot,
         runtimeMode,
         workspaceId: options?.workspaceId,
@@ -83,6 +30,8 @@ async function callTool(projectRoot, runtimeMode, name, args, options) {
             }
             : undefined
     });
+}
+async function callToolWithRuntime(runtime, name, args, options) {
     const handler = runtime.server._requestHandlers.get('tools/call');
     if (!handler) {
         throw new Error('tools/call handler not registered');
@@ -112,20 +61,71 @@ async function callTool(projectRoot, runtimeMode, name, args, options) {
         }
     }, {});
 }
-async function readResource(projectRoot, runtimeMode, uri, options) {
-    const runtime = createTaskforceMcpServer({
+async function subscribeResource(runtime, uri) {
+    const handler = runtime.server._requestHandlers.get('resources/subscribe');
+    if (!handler) {
+        throw new Error('resources/subscribe handler not registered');
+    }
+    await handler({
+        jsonrpc: '2.0',
+        id: `test-resources-subscribe-${uri}`,
+        method: 'resources/subscribe',
+        params: { uri }
+    }, {});
+}
+function createProjectRoot() {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-runtime-'));
+    const core = new TaskforceCore({
         projectRoot,
-        runtimeMode,
-        workspaceId: options?.workspaceId,
-        logStartup: false,
-        auth: runtimeMode === 'cloud'
-            ? {
-                scopes: ['tasks:read', 'tasks:write', 'workspace:read'],
-                userId: options?.authUserId || 'owner-1',
-                actorType: 'oauth'
-            }
-            : undefined
+        storagePath: path.join(projectRoot, '.taskforce')
     });
+    try {
+        Object.defineProperty(core, 'getAccountAccessStatus', {
+            configurable: true,
+            value: () => ({
+                gate: 'ok',
+                hasEntitlement: true,
+                canAccessApp: true,
+                canAccessPlans: true,
+                planSelectionRequired: false,
+                message: null,
+                entitlement: null
+            })
+        });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        core.ensureBootstrapUserAccess({
+            userId: 'owner-1',
+            workspaceId: 'workspace-1',
+            role: 'owner',
+            email: 'owner-1@example.com'
+        });
+    }
+    finally {
+        core.close();
+    }
+    return projectRoot;
+}
+async function listTools(projectRoot, runtimeMode) {
+    const runtime = createRuntime(projectRoot, runtimeMode);
+    const handler = runtime.server._requestHandlers.get('tools/list');
+    if (!handler) {
+        throw new Error('tools/list handler not registered');
+    }
+    return await handler({
+        jsonrpc: '2.0',
+        id: 'test-tools-list',
+        method: 'tools/list',
+        params: {}
+    }, {});
+}
+async function callTool(projectRoot, runtimeMode, name, args, options) {
+    const runtime = createRuntime(projectRoot, runtimeMode, options);
+    return await callToolWithRuntime(runtime, name, args, {
+        resolveProfile: options?.resolveProfile,
+    });
+}
+async function readResource(projectRoot, runtimeMode, uri, options) {
+    const runtime = createRuntime(projectRoot, runtimeMode, options);
     const handler = runtime.server._requestHandlers.get('resources/read');
     if (!handler) {
         throw new Error('resources/read handler not registered');
@@ -138,19 +138,7 @@ async function readResource(projectRoot, runtimeMode, uri, options) {
     }, {});
 }
 async function listResources(projectRoot, runtimeMode, options) {
-    const runtime = createTaskforceMcpServer({
-        projectRoot,
-        runtimeMode,
-        workspaceId: options?.workspaceId,
-        logStartup: false,
-        auth: runtimeMode === 'cloud'
-            ? {
-                scopes: ['tasks:read', 'tasks:write', 'workspace:read'],
-                userId: options?.authUserId || 'owner-1',
-                actorType: 'oauth'
-            }
-            : undefined
-    });
+    const runtime = createRuntime(projectRoot, runtimeMode, options);
     const handler = runtime.server._requestHandlers.get('resources/list');
     if (!handler) {
         throw new Error('resources/list handler not registered');
@@ -304,6 +292,29 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('does not let TASKFORCE_TOOLS prune the runtime tool catalog', async () => {
+        const projectRoot = createProjectRoot();
+        const previousValue = process.env.TASKFORCE_TOOLS;
+        process.env.TASKFORCE_TOOLS = 'get_task';
+        try {
+            const result = await listTools(projectRoot, 'cloud');
+            const runtimeToolNames = result.tools.map((tool) => tool.name).sort();
+            const registryToolNames = Object.entries(MCP_TOOL_REGISTRY)
+                .filter(([, entry]) => entry.permission.kind !== 'local-only' && entry.permission.kind !== 'session-only')
+                .map(([name]) => name)
+                .sort();
+            expect(runtimeToolNames).toEqual(registryToolNames);
+        }
+        finally {
+            if (previousValue === undefined) {
+                delete process.env.TASKFORCE_TOOLS;
+            }
+            else {
+                process.env.TASKFORCE_TOOLS = previousValue;
+            }
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('includes local-only guidance in local runtime tool descriptions', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -1500,6 +1511,150 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('builds workstream listings from one historical task snapshot and returns task summaries', async () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({
+            projectRoot,
+            storagePath: path.join(projectRoot, '.taskforce')
+        });
+        try {
+            const category = core.getCategories()[0]?.value;
+            const type = core.getTypes()[0]?.value;
+            const firstWorkstream = core.createWorkstream({ title: 'Workstream one' }, 'workspace-1');
+            const secondWorkstream = core.createWorkstream({ title: 'Workstream two' }, 'workspace-1');
+            core.createTask({
+                title: 'Linked task one',
+                category,
+                type,
+                workstreamId: firstWorkstream.id,
+            }, { workspaceId: 'workspace-1', actorRef: 'owner-1' });
+            core.createTask({
+                title: 'Linked task two',
+                category,
+                type,
+                workstreamId: secondWorkstream.id,
+            }, { workspaceId: 'workspace-1', actorRef: 'owner-1' });
+            const archivedTask = core.createTask({
+                title: 'Archived linked task',
+                category,
+                type,
+                workstreamId: firstWorkstream.id,
+                status: 'done',
+            }, { workspaceId: 'workspace-1', actorRef: 'owner-1' });
+            core.archiveTask(archivedTask.id, false, undefined, 'workspace-1', { actorRef: 'owner-1' });
+        }
+        finally {
+            core.close();
+        }
+        const listTasksSpy = vi.spyOn(TaskforceCore.prototype, 'listTasks');
+        const listArchiveSpy = vi.spyOn(TaskforceCore.prototype, 'listArchive');
+        try {
+            const beforeListTasksCalls = listTasksSpy.mock.calls.length;
+            const beforeListArchiveCalls = listArchiveSpy.mock.calls.length;
+            const payload = parseToolJson(await callTool(projectRoot, 'local', 'list_workstreams', {}));
+            const firstWorkstreamPayload = payload.workstreams.find((entry) => entry.workstream.title === 'Workstream one');
+            const linkedTask = firstWorkstreamPayload?.tasks.find((task) => task.title === 'Archived linked task');
+            expect(listTasksSpy.mock.calls.length - beforeListTasksCalls).toBe(1);
+            expect(listArchiveSpy.mock.calls.length - beforeListArchiveCalls).toBe(1);
+            expect(linkedTask).toMatchObject({
+                title: 'Archived linked task',
+                workstreamId: firstWorkstreamPayload?.workstream.id,
+                status: 'done',
+            });
+            expect(linkedTask.description).toBeUndefined();
+            expect(linkedTask.comments).toBeUndefined();
+            expect(linkedTask.activity).toBeUndefined();
+            expect(linkedTask.attachments).toBeUndefined();
+            expect(linkedTask.checklistItems).toBeUndefined();
+        }
+        finally {
+            listTasksSpy.mockRestore();
+            listArchiveSpy.mockRestore();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('queues bulk resource invalidations instead of awaiting them in the write path', async () => {
+        const projectRoot = createProjectRoot();
+        const runtime = createRuntime(projectRoot, 'local');
+        const resourceUri = `taskforce://${path.basename(projectRoot)}/tasks`;
+        const sendResourceUpdatedSpy = vi
+            .spyOn(runtime.server, 'sendResourceUpdated')
+            .mockImplementation(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        });
+        try {
+            await subscribeResource(runtime, resourceUri);
+            const created = parseToolJson(await callToolWithRuntime(runtime, 'create_task', {
+                title: 'Queued invalidation task'
+            }));
+            expect(created.title).toBe('Queued invalidation task');
+            expect(sendResourceUpdatedSpy).not.toHaveBeenCalled();
+            await new Promise((resolve) => setTimeout(resolve, 40));
+            expect(sendResourceUpdatedSpy).toHaveBeenCalledTimes(1);
+            expect(sendResourceUpdatedSpy).toHaveBeenCalledWith({ uri: resourceUri });
+        }
+        finally {
+            sendResourceUpdatedSpy.mockRestore();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('reads the bulk tasks resource as summary-only rows', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const created = parseToolJson(await callTool(projectRoot, 'local', 'create_task', {
+                title: 'Verbose task',
+                description: 'This should stay off the bulk tasks resource'
+            }));
+            await callTool(projectRoot, 'local', 'add_comment', {
+                id: created.referenceLabel,
+                text: 'This comment should stay off the bulk tasks resource',
+                author: 'ai-profile-019d15c5-6ad3-7bf0-9b9e-fa9c366c3ff4'
+            });
+            const taskResource = await readResource(projectRoot, 'cloud', `taskforce://${path.basename(projectRoot)}/tasks`, {
+                workspaceId: 'workspace-1',
+                authUserId: 'owner-1'
+            });
+            const payload = JSON.parse(String(taskResource.contents[0]?.text || '{}'));
+            const resourceTask = payload.tasks.find((task) => task.referenceLabel === created.referenceLabel);
+            expect(resourceTask).toMatchObject({
+                referenceLabel: created.referenceLabel,
+                title: 'Verbose task',
+            });
+            expect(resourceTask.description).toBeUndefined();
+            expect(resourceTask.comments).toBeUndefined();
+            expect(resourceTask.activity).toBeUndefined();
+            expect(resourceTask.attachments).toBeUndefined();
+            expect(resourceTask.checklistItems).toBeUndefined();
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('reads initiative listings with summary initiative and workstream records only', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const initiative = parseToolJson(await callTool(projectRoot, 'local', 'create_initiative', {
+                title: 'Summary initiative',
+                description: 'Verbose initiative details should stay off the bulk listing'
+            }));
+            await callTool(projectRoot, 'local', 'create_workstream', {
+                title: 'Summary workstream',
+                description: 'Verbose workstream details should stay off the bulk listing',
+                initiativeId: initiative.initiative.referenceLabel
+            });
+            const initiatives = parseToolJson(await callTool(projectRoot, 'local', 'list_initiatives', {}));
+            const listedInitiative = initiatives.initiatives.find((entry) => entry.initiative.referenceLabel === initiative.initiative.referenceLabel);
+            const listedWorkstream = listedInitiative?.workstreams.find((entry) => entry.title === 'Summary workstream');
+            expect(listedInitiative).toBeTruthy();
+            expect(listedInitiative.initiative.description).toBeUndefined();
+            expect(listedWorkstream).toBeTruthy();
+            expect(listedWorkstream.description).toBeUndefined();
+            expect(listedWorkstream.taskIds).toBeUndefined();
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('creates MCP tasks as unassigned when no explicit assignee is provided', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -1541,6 +1696,42 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('returns summary-shaped task entries from the shared tasks resource', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            core.createTask({
+                title: 'Resource summary task',
+                description: 'Verbose task description',
+                comments: [{ id: 'comment-1', author: 'user', text: 'Hello', timestamp: '2026-04-13T01:00:00.000Z' }],
+                attachments: [{ name: 'note.md', path: 'notes/note.md' }],
+                checklistItems: [{ id: 'item-1', taskId: 'temp', title: 'Check me', isCompleted: false, order: 0, createdAt: '2026-04-13T01:00:00.000Z' }],
+            }, {
+                workspaceId: 'workspace-1',
+                actorRef: 'owner-1'
+            });
+            core.close();
+            const tasksResource = await readResource(projectRoot, 'cloud', `taskforce://${path.basename(projectRoot)}/tasks`, {
+                workspaceId: 'workspace-1',
+                authUserId: 'owner-1'
+            });
+            const payload = JSON.parse(String(tasksResource.contents[0]?.text || '{}'));
+            const task = payload.tasks.find((entry) => entry.title === 'Resource summary task');
+            expect(task).toBeDefined();
+            expect(task.description).toBeUndefined();
+            expect(task.comments).toBeUndefined();
+            expect(task.taskEvents).toBeUndefined();
+            expect(task.activity).toBeUndefined();
+            expect(task.attachments).toBeUndefined();
+            expect(task.checklistItems).toBeUndefined();
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('persists save_task_attachment through canonical task attachments', async () => {
         const projectRoot = createProjectRoot();
         try {

package/dist/migrations/billingSchemaParity.test.js

@@ -25,6 +25,7 @@ describe('billing schema parity', () => {
             expect(names.has('user_billing')).toBe(true);
             expect(names.has('stripe_webhook_events')).toBe(true);
             expect(names.has('stripe_webhook_failures')).toBe(true);
+            expect(names.has('billing_checkout_attempts')).toBe(true);
             expect(names.has('billing_config')).toBe(true);
             expect(names.has('billing_price_mappings')).toBe(true);
         }
@@ -101,9 +102,11 @@ describe('billing schema parity', () => {
         expect(sql).toContain('CREATE TABLE IF NOT EXISTS user_billing');
         expect(sql).toContain('CREATE TABLE IF NOT EXISTS stripe_webhook_events');
         expect(sql).toContain('CREATE TABLE IF NOT EXISTS stripe_webhook_failures');
+        expect(sql).toContain('CREATE TABLE IF NOT EXISTS billing_checkout_attempts');
         expect(sql).toContain('CREATE TABLE IF NOT EXISTS billing_config');
         expect(sql).toContain('CREATE TABLE IF NOT EXISTS billing_price_mappings');
         expect(sql).toContain('CREATE INDEX IF NOT EXISTS idx_stripe_webhook_failures_purge_after');
+        expect(sql).toContain('CREATE INDEX IF NOT EXISTS idx_billing_checkout_attempts_user_status');
         expect(sql).toContain('CREATE INDEX IF NOT EXISTS idx_billing_price_mappings_plan');
         expect(sql).toContain('CREATE UNIQUE INDEX IF NOT EXISTS idx_billing_price_mappings_active_interval');
     });

package/dist/migrations/taskSchemaMigrations.js

@@ -493,6 +493,18 @@ export function ensureBillingSchema(db) {
             created_at TEXT NOT NULL
         );
 
+        CREATE TABLE IF NOT EXISTS billing_checkout_attempts (
+            session_id TEXT PRIMARY KEY,
+            tenant_id TEXT NOT NULL DEFAULT 'default',
+            user_id TEXT NOT NULL,
+            plan_version_id TEXT NOT NULL,
+            billing_interval TEXT,
+            status TEXT NOT NULL DEFAULT 'open',
+            expires_at TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
         CREATE TABLE IF NOT EXISTS billing_config (
             tenant_id TEXT PRIMARY KEY,
             config_json TEXT NOT NULL DEFAULT '{}',
@@ -520,6 +532,8 @@ export function ensureBillingSchema(db) {
         CREATE INDEX IF NOT EXISTS idx_stripe_webhook_failures_tenant ON stripe_webhook_failures(tenant_id);
         CREATE INDEX IF NOT EXISTS idx_stripe_webhook_failures_event ON stripe_webhook_failures(event_id);
         CREATE INDEX IF NOT EXISTS idx_stripe_webhook_failures_purge_after ON stripe_webhook_failures(purge_after);
+        CREATE INDEX IF NOT EXISTS idx_billing_checkout_attempts_user_status ON billing_checkout_attempts(tenant_id, user_id, status, created_at);
+        CREATE INDEX IF NOT EXISTS idx_billing_checkout_attempts_plan_status ON billing_checkout_attempts(tenant_id, plan_version_id, status, created_at);
         CREATE INDEX IF NOT EXISTS idx_billing_price_mappings_plan ON billing_price_mappings(tenant_id, plan_version_id);
         CREATE INDEX IF NOT EXISTS idx_billing_price_mappings_active ON billing_price_mappings(tenant_id, active);
     `);
@@ -723,6 +737,7 @@ export function ensureEntitlementsSchema(db) {
             updated_by TEXT,
             created_at TEXT NOT NULL,
             updated_at TEXT NOT NULL,
+            FOREIGN KEY (account_id) REFERENCES users(id) ON DELETE CASCADE,
             FOREIGN KEY (plan_version_id) REFERENCES plan_versions(plan_version_id)
         );
 

package/dist/server/index.cookieProxy.test.js

@@ -22,6 +22,7 @@ describe('proxy cookie rewrite helpers', () => {
         expect(shouldProxyCloudPath('/api/taskforce/public/site-config-script')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/version')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/account/entitlements')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/account/profile-summary')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/account/team-management-access')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/admin/mcp-audit-logs')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/billing/status')).toBe(true);

package/dist/server/index.js

@@ -109,6 +109,8 @@ export function shouldProxyCloudPath(pathname) {
         || pathname === PUBLIC_SITE_CONFIG_SCRIPT_PATH
         || pathname === '/api/taskforce/version'
         || pathname === '/api/taskforce/account/entitlements'
+        || pathname === '/api/taskforce/account/profile-summary'
+        || pathname === '/api/taskforce/account/team-management-access'
         || pathname.startsWith('/api/taskforce/admin/')
         || pathname.startsWith('/api/taskforce/billing/')
         || pathname.startsWith('/api/taskforce/auth/')

package/dist/server/index.test.js

@@ -86,7 +86,8 @@ describe('shouldProxyCloudPath', () => {
         expect(shouldProxyCloudPath('/api/taskforce/admin/users')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/billing/plans')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/auth/login')).toBe(true);
-        expect(shouldProxyCloudPath('/api/taskforce/account/team-management-access')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/account/profile-summary')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/account/team-management-access')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/public/site-config')).toBe(true);
         expect(shouldProxyCloudPath('/api/taskforce/public/site-config-script')).toBe(true);
     });