@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/mcp/runtime.test.js

@@ -323,6 +323,7 @@ describe('Taskforce MCP tool descriptions', () => {
             const getTask = getTool(result, 'get_task');
             const getPaths = getTool(result, 'get_paths');
             const searchImages = getTool(result, 'search_images');
+            const getImage = getTool(result, 'get_image');
             const getDocument = getTool(result, 'get_document');
             const searchDocuments = getTool(result, 'search_documents');
             const listAnnotatedAttachmentSessions = getTool(result, 'get_annotated_attachment_sessions');
@@ -341,10 +342,13 @@ describe('Taskforce MCP tool descriptions', () => {
             expect(getTask.description).toContain('Do not use this for image references like I-123 or document references like D-123.');
             expect(getPaths.description).toContain('Get project and Taskforce storage paths.');
             expect(searchImages.description).toContain('I-123 reference');
+            expect(getImage.description).toContain('placement, or visual correction feedback');
             expect(getDocument.description).toContain('D-123');
             expect(searchDocuments.description).toContain('D-123 reference');
             expect(listAnnotatedAttachmentSessions.description).toContain('saved annotation sessions');
+            expect(listAnnotatedAttachmentSessions.description).toContain('inspect the saved session payload next');
             expect(readAnnotatedAttachmentPayload.description).toContain('derived crop hints');
+            expect(readAnnotatedAttachmentPayload.description).toContain('authoritative instruction source');
             expect(createAnnotatedAttachmentSession.description).toContain('before adding markers');
             expect(deleteAnnotatedAttachmentSession.description).toContain('rather than deleting markers one by one');
             expect(reviewImage.description).toContain('first-pass visual review');
@@ -400,6 +404,7 @@ describe('Taskforce MCP tool descriptions', () => {
             expect(getTask.description).toContain('Do not use this for image references like I-123 or document references like D-123.');
             expect(searchImages.description).toContain('get_image');
             expect(getImage.description).toContain('Use this first when the user references an image');
+            expect(getImage.description).toContain('read the saved annotation payload before making changes');
             expect(searchDocuments.description).toContain('get_document');
             expect(searchDocuments.description).toContain('read_document_content');
             expect(getDocument.description).toContain('Use this first when the user references a document');
@@ -733,6 +738,63 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('creates a separate cloud profile and persists metadata when a same-name local profile already exists', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const initial = parseToolJson(await callTool(projectRoot, 'local', 'resolve_profile', {
+                name: 'Automation Codex',
+                icon: 'Bot',
+                color: '#64748b'
+            }));
+            expect(initial.profile.description).toBeNull();
+            expect(initial.profile.role).toBeNull();
+            const currentProfile = parseToolJson(await callTool(projectRoot, 'cloud', 'get_current_profile', {}, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex',
+                authAiProfileDescription: 'OpenAI Codex coding agent connected through MCP.',
+                authAiProfileRole: 'Coding Agent',
+                authAiProfileProvider: 'OpenAI',
+                authAiProfileModel: 'Codex',
+                authAiProfileSurfaceType: 'coding_tool'
+            }));
+            expect(currentProfile.profile).toEqual(expect.objectContaining({
+                name: 'Automation Codex',
+                description: 'OpenAI Codex coding agent connected through MCP.',
+                role: 'Coding Agent',
+                provider: 'OpenAI',
+                model: 'Codex',
+                surfaceType: 'coding_tool',
+                seatScope: 'cloud_metered'
+            }));
+            expect(currentProfile.profile.id).not.toBe(initial.profile.id);
+            const reloadedCore = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            expect(reloadedCore.listAiProfiles('workspace-1')).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    id: initial.profile.id,
+                    name: 'Automation Codex',
+                    seatScope: 'local_unmetered'
+                }),
+                expect.objectContaining({
+                    id: currentProfile.profile.id,
+                    name: 'Automation Codex',
+                    description: 'OpenAI Codex coding agent connected through MCP.',
+                    role: 'Coding Agent',
+                    provider: 'OpenAI',
+                    model: 'Codex',
+                    surfaceType: 'coding_tool',
+                    seatScope: 'cloud_metered'
+                })
+            ]));
+            reloadedCore.close();
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('allows mutating MCP tools in a fresh runtime when profileToken is passed', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -759,9 +821,12 @@ describe('Taskforce MCP tool descriptions', () => {
     it('allows mutating cloud MCP tools when the connection is configured with an AI profile token', async () => {
         const projectRoot = createProjectRoot();
         try {
-            const resolved = parseToolJson(await callTool(projectRoot, 'local', 'resolve_profile', {
+            const resolved = parseToolJson(await callTool(projectRoot, 'cloud', 'resolve_profile', {
                 name: 'Automation Codex'
-            }, { resolveProfile: false }));
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false
+            }));
             const created = parseToolJson(await callTool(projectRoot, 'cloud', 'create_task', {
                 title: 'Configured token write'
             }, {
@@ -816,6 +881,154 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('blocks cloud auto-bind when the configured AI profile has been retired by name until resolve_profile explicitly reactivates it', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            const resolved = core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Automation Codex',
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.archiveAiProfile({
+                workspaceId: 'workspace-1',
+                profileId: resolved.profile.id,
+                archivedBy: 'owner-1',
+                reason: 'manual_archive'
+            });
+            core.close();
+            const blocked = await callTool(projectRoot, 'cloud', 'create_task', {
+                title: 'Should stay retired'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex'
+            });
+            expect(blocked.isError).toBe(true);
+            const blockedPayload = parseToolJson(blocked);
+            expect(blockedPayload.code).toBe('AI_PROFILE_RETIRED');
+            expect(blockedPayload.error).toContain('has been retired from this workspace');
+            expect(blockedPayload.nextTool).toBe('resolve_profile');
+            const reactivated = parseToolJson(await callTool(projectRoot, 'cloud', 'resolve_profile', {
+                name: 'Automation Codex',
+                surfaceType: 'agent'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex'
+            }));
+            expect(reactivated.created).toBe(false);
+            expect(reactivated.profile.id).toBe(resolved.profile.id);
+            expect(reactivated.profile.archivedAt ?? null).toBeNull();
+            const created = parseToolJson(await callTool(projectRoot, 'cloud', 'create_task', {
+                title: 'Reactivated automation write'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex'
+            }));
+            expect(created.title).toBe('Reactivated automation write');
+            expect(created.createdBy).toBe(resolved.profile.id);
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('blocks cloud auto-bind when the configured AI profile token belongs to a retired profile', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            const resolved = core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Automation Codex',
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.archiveAiProfile({
+                workspaceId: 'workspace-1',
+                profileId: resolved.profile.id,
+                archivedBy: 'owner-1',
+                reason: 'manual_archive'
+            });
+            core.close();
+            const blocked = await callTool(projectRoot, 'cloud', 'create_task', {
+                title: 'Token should stay retired'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileToken: resolved.profile.profileToken,
+                authAiProfileName: 'Automation Codex'
+            });
+            expect(blocked.isError).toBe(true);
+            const blockedPayload = parseToolJson(blocked);
+            expect(blockedPayload.code).toBe('AI_PROFILE_RETIRED');
+            expect(blockedPayload.details).toEqual(expect.objectContaining({
+                profileId: resolved.profile.id,
+                profileToken: resolved.profile.profileToken,
+                archivedReason: 'manual_archive'
+            }));
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('blocks cloud auto-bind when the workspace has no remaining ai profile seats', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-1',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.updatePlanVersionFeatures({
+                planVersionId: 'free-v1',
+                features: [
+                    { featureKey: 'collaboration.ai_profiles', access: 'limited', config: { maxAiProfiles: 1 } }
+                ]
+            });
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                planVersionId: 'free-v1',
+                entitlementState: 'active',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Existing Automation Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.close();
+            const result = await callTool(projectRoot, 'cloud', 'create_task', {
+                title: 'Blocked automation write'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex'
+            });
+            expect(result.isError).toBe(true);
+            const payload = parseToolJson(result);
+            expect(payload.code).toBe('AI_PROFILE_LIMIT_REACHED');
+            expect(payload.error).toContain('No AI seats are available for this workspace');
+            expect(payload.details).toEqual({
+                workspaceId: 'workspace-1',
+                limit: 1,
+                used: 1,
+                remaining: 0
+            });
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('rejects invalid profileToken values on mutating MCP tools', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -876,6 +1089,185 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('surfaces ai profile seat limits when an invalid per-call token falls back to a configured AI name', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-1',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.updatePlanVersionFeatures({
+                planVersionId: 'free-v1',
+                features: [
+                    { featureKey: 'collaboration.ai_profiles', access: 'limited', config: { maxAiProfiles: 1 } }
+                ]
+            });
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                planVersionId: 'free-v1',
+                entitlementState: 'active',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Existing Automation Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.close();
+            const result = await callTool(projectRoot, 'cloud', 'create_task', {
+                title: 'Recovered per-call token write',
+                profileToken: 'tfp_invalid_token',
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false,
+                authAiProfileName: 'Automation Codex'
+            });
+            expect(result.isError).toBe(true);
+            const payload = parseToolJson(result);
+            expect(payload.code).toBe('AI_PROFILE_LIMIT_REACHED');
+            expect(payload.error).toContain('No AI seats are available for this workspace');
+            expect(payload.details).toEqual({
+                workspaceId: 'workspace-1',
+                limit: 1,
+                used: 1,
+                remaining: 0
+            });
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('keeps local MCP profile resolution unmetered even when cloud seats are full', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            core.upsertPlanCatalog({ planId: 'free', displayName: 'Free', status: 'active' });
+            core.ensureBootstrapUserAccess({
+                userId: 'owner-u1',
+                workspaceId: 'workspace-1',
+                role: 'owner',
+                email: 'owner@example.com'
+            });
+            core.updatePlanVersionFeatures({
+                planVersionId: 'free-v1',
+                features: [
+                    { featureKey: 'collaboration.ai_profiles', access: 'limited', config: { maxAiProfiles: 1 } }
+                ]
+            });
+            core.updateAccountEntitlement({
+                accountId: 'owner-u1',
+                planVersionId: 'free-v1',
+                entitlementState: 'active',
+                actorUserId: 'system-admin',
+                actorRole: 'system_admin'
+            });
+            core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Existing Automation Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.close();
+            const payload = parseToolJson(await callTool(projectRoot, 'local', 'resolve_profile', {
+                name: 'Local Codex'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false
+            }));
+            expect(payload.created).toBe(true);
+            expect(payload.profile.name).toBe('Local Codex');
+            expect(payload.profile.seatScope).toBe('local_unmetered');
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('derives profile seat scope from the MCP runtime instead of auth metadata', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const localRuntime = createTaskforceMcpServer({
+                projectRoot,
+                runtimeMode: 'local',
+                workspaceId: 'workspace-1',
+                logStartup: false,
+                auth: {
+                    aiProfileSeatScope: 'cloud_metered',
+                    aiProfileName: 'Codex',
+                    aiProfileRole: 'Implementation',
+                    aiProfileProvider: 'OpenAI',
+                    aiProfileModel: 'gpt-5',
+                    aiProfileSurfaceType: 'coding_tool',
+                }
+            });
+            const localPayload = parseToolJson(await callToolWithRuntime(localRuntime, 'resolve_profile', {
+                name: 'Codex',
+                surfaceType: 'coding_tool',
+            }, {
+                resolveProfile: false
+            }));
+            expect(localPayload.profile.seatScope).toBe('local_unmetered');
+            const cloudRuntime = createTaskforceMcpServer({
+                projectRoot,
+                runtimeMode: 'cloud',
+                workspaceId: 'workspace-1',
+                logStartup: false,
+                auth: {
+                    scopes: ['tasks:read', 'tasks:write', 'workspace:read'],
+                    userId: 'owner-1',
+                    actorType: 'oauth',
+                    aiProfileSeatScope: 'local_unmetered',
+                    aiProfileName: 'Cloud Codex',
+                    aiProfileSurfaceType: 'coding_tool',
+                }
+            });
+            const cloudPayload = parseToolJson(await callToolWithRuntime(cloudRuntime, 'resolve_profile', {
+                name: 'Cloud Codex',
+                surfaceType: 'coding_tool',
+            }, {
+                resolveProfile: false
+            }));
+            expect(cloudPayload.profile.seatScope).toBe('cloud_metered');
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
+    it('creates a separate local MCP profile when a cloud profile with the same name already exists', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            const cloud = core.resolveAiProfile({
+                workspaceId: 'workspace-1',
+                name: 'Codex',
+                surfaceType: 'coding_tool'
+            }, { trustedSeatScope: 'cloud_metered' });
+            core.close();
+            const payload = parseToolJson(await callTool(projectRoot, 'local', 'resolve_profile', {
+                name: 'Codex',
+                surfaceType: 'coding_tool'
+            }, {
+                workspaceId: 'workspace-1',
+                resolveProfile: false
+            }));
+            expect(payload.created).toBe(true);
+            expect(payload.profile.id).not.toBe(cloud.profile.id);
+            expect(payload.profile.seatScope).toBe('local_unmetered');
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('claims unassigned tasks and marks them in progress through start_task', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -2486,6 +2878,52 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('accepts documented schedule helper arguments', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            const first = core.createTask({ title: 'First documented schedule helper test' }, { workspaceId: 'workspace-1' });
+            const second = core.createTask({ title: 'Second documented schedule helper test' }, { workspaceId: 'workspace-1' });
+            core.close();
+            const board = parseToolJson(await callTool(projectRoot, 'local', 'get_schedule_board', {}));
+            expect(board.week).toMatch(/^\d{4}-W\d{2}$/);
+            const scheduled = parseToolJson(await callTool(projectRoot, 'local', 'schedule_task', {
+                taskId: first.referenceLabel,
+                date: '2099-01-05',
+                order: 3
+            }));
+            expect(scheduled.scheduling.persistedDate).toBe('2099-01-05');
+            expect(scheduled.scheduling.persistedOrderInDay).toBe(3);
+            await callTool(projectRoot, 'local', 'reorder_scheduled_tasks', {
+                date: '2099-01-05',
+                taskIds: [second.referenceLabel, first.referenceLabel]
+            });
+            await callTool(projectRoot, 'local', 'unschedule_task', {
+                taskId: first.referenceLabel
+            });
+            const after = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            try {
+                const firstTask = after.getTask(first.id, 'workspace-1');
+                const secondTask = after.getTask(second.id, 'workspace-1');
+                expect(firstTask?.scheduledDate).toBeNull();
+                expect(firstTask?.orderInDay).toBeNull();
+                expect(secondTask?.scheduledDate).toBe('2099-01-05');
+                expect(secondTask?.orderInDay).toBe(0);
+            }
+            finally {
+                after.close();
+            }
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('maps legacy agent assignee writes to unassigned even when a profile is resolved', async () => {
         const projectRoot = createProjectRoot();
         try {

package/dist/mcp/taskPlanningRegistrar.d.ts

@@ -0,0 +1,2 @@
+import type { DomainToolExecutor, RegisterMcpTool } from './toolCatalog.js';
+export declare function registerTaskPlanningTools(registerTool: RegisterMcpTool, executeTool: DomainToolExecutor): void;