@taskforcehq/taskforce 0.3.305 → 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,7 +738,7 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('updates and persists metadata when cloud auto-bind reuses an existing exact-match profile', async () => {
+    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', {
@@ -754,29 +759,36 @@ describe('Taskforce MCP tool descriptions', () => {
                 authAiProfileSurfaceType: 'coding_tool'
             }));
             expect(currentProfile.profile).toEqual(expect.objectContaining({
-                id: initial.profile.id,
                 name: 'Automation Codex',
                 description: 'OpenAI Codex coding agent connected through MCP.',
                 role: 'Coding Agent',
                 provider: 'OpenAI',
                 model: 'Codex',
-                surfaceType: 'coding_tool'
+                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(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'
+                    surfaceType: 'coding_tool',
+                    seatScope: 'cloud_metered'
                 })
-            ]);
+            ]));
             reloadedCore.close();
         }
         finally {
@@ -809,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'
             }, {
@@ -866,6 +881,100 @@ 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 {
@@ -895,8 +1004,8 @@ describe('Taskforce MCP tool descriptions', () => {
             });
             core.resolveAiProfile({
                 workspaceId: 'workspace-1',
-                name: 'Existing Automation Bot'
-            });
+                name: 'Existing Automation Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
             core.close();
             const result = await callTool(projectRoot, 'cloud', 'create_task', {
                 title: 'Blocked automation write'
@@ -1009,8 +1118,8 @@ describe('Taskforce MCP tool descriptions', () => {
             });
             core.resolveAiProfile({
                 workspaceId: 'workspace-1',
-                name: 'Existing Automation Bot'
-            });
+                name: 'Existing Automation Bot',
+            }, { trustedSeatScope: 'cloud_metered' });
             core.close();
             const result = await callTool(projectRoot, 'cloud', 'create_task', {
                 title: 'Recovered per-call token write',
@@ -1035,6 +1144,130 @@ describe('Taskforce MCP tool descriptions', () => {
             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 {
@@ -2645,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/migrations/taskSchemaMigrations.d.ts

@@ -1,6 +1,5 @@
 import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
 export declare function ensureTenantSchema(db: DatabaseAdapter): void;
-export declare function ensureParentTaskSchema(db: DatabaseAdapter): void;
 export declare function ensureScheduleTaskSchema(db: DatabaseAdapter): void;
 export declare function ensureAssigneeTaskSchema(db: DatabaseAdapter): void;
 export declare function ensureTaskReferenceSchema(db: DatabaseAdapter): void;
@@ -14,3 +13,4 @@ export declare function ensureSyncEventsSchema(db: DatabaseAdapter): void;
 export declare function ensureWorkspaceDocumentsSchema(db: DatabaseAdapter): void;
 export declare function ensureAnnotatedAttachmentSessionsSchema(db: DatabaseAdapter): void;
 export declare function ensureDocumentReviewSessionsSchema(db: DatabaseAdapter): void;
+export declare function ensureAuthIdentitySchema(db: DatabaseAdapter): void;