@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/mcp/runtime.test.js

@@ -436,11 +436,11 @@ describe('Taskforce MCP tool descriptions', () => {
             expect(linkTaskContext.description).toContain('external http(s) URL');
             expect(saveTaskAttachment.description).toContain('generated content');
             expect(saveTaskAttachment.description).toContain('overwrite=true');
-            expect(saveTaskAttachment.description).toContain('AI-authored markdown/text should usually be passed inline via content');
+            expect(saveTaskAttachment.description).toContain('use inline content for AI-authored markdown/text');
             expect(saveTaskAttachment.inputSchema).toBeDefined();
             const saveTaskAttachmentSchema = saveTaskAttachment.inputSchema;
             expect(saveTaskAttachmentSchema.properties.content.description).toContain('use this for AI-authored markdown/text attachments');
-            expect(saveTaskAttachmentSchema.properties.sourcePath.description).toContain('local runtime only today');
+            expect(saveTaskAttachmentSchema.properties.sourcePath.description).toContain('approved agent workspace root');
             expect(resolveProfile.description).toContain('AI collaborator profile');
             expect(resolveProfile.description).toContain('Update semantics');
             expect(resolveProfile.description).toContain('empty strings are ignored rather than clearing');
@@ -733,6 +733,56 @@ 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 () => {
+        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({
+                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'
+            }));
+            const reloadedCore = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            expect(reloadedCore.listAiProfiles('workspace-1')).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'
+                })
+            ]);
+            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 {
@@ -816,6 +866,60 @@ describe('Taskforce MCP tool descriptions', () => {
             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'
+            });
+            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 +980,61 @@ 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'
+            });
+            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('claims unassigned tasks and marks them in progress through start_task', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -1667,6 +1826,40 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
+    it('returns summary-only rows from list_tasks json output', async () => {
+        const projectRoot = createProjectRoot();
+        try {
+            const created = parseToolJson(await callTool(projectRoot, 'local', 'create_task', {
+                title: 'List summary task',
+                description: 'Verbose description that should not appear in list rows'
+            }));
+            await callTool(projectRoot, 'local', 'replace_task_checklist', {
+                taskId: created.referenceLabel,
+                items: [
+                    { title: 'Checklist item one', isCompleted: false }
+                ]
+            });
+            await callTool(projectRoot, 'local', 'add_comment', {
+                id: created.referenceLabel,
+                text: 'Verbose comment that should not appear in list rows',
+                author: 'ai-profile-019d15c5-6ad3-7bf0-9b9e-fa9c366c3ff4'
+            });
+            const listed = parseToolJson(await callTool(projectRoot, 'local', 'list_tasks', {
+                format: 'json'
+            }));
+            const row = listed.find((task) => task.referenceLabel === created.referenceLabel);
+            expect(row).toBeTruthy();
+            expect(row.description).toBeUndefined();
+            expect(row.comments).toBeUndefined();
+            expect(row.taskEvents).toBeUndefined();
+            expect(row.activity).toBeUndefined();
+            expect(row.attachments).toBeUndefined();
+            expect(row.checklistItems).toBeUndefined();
+        }
+        finally {
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    });
     it('reads task resources by T-XXX reference and exposes version/scope in config resource', async () => {
         const projectRoot = createProjectRoot();
         try {
@@ -1961,8 +2154,45 @@ describe('Taskforce MCP tool descriptions', () => {
             fs.rmSync(projectRoot, { recursive: true, force: true });
         }
     });
-    it('rejects sourcePath for save_task_attachment in cloud runtime', async () => {
+    it('allows save_task_attachment sourcePath in cloud runtime for approved agent workspace roots', async () => {
         const projectRoot = createProjectRoot();
+        const agentWorkspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-agent-workspace-'));
+        const previousRoots = process.env.TASKFORCE_ALLOWED_ATTACHMENT_SOURCE_ROOTS;
+        try {
+            const core = new TaskforceCore({
+                projectRoot,
+                storagePath: path.join(projectRoot, '.taskforce')
+            });
+            const task = core.createTask({ title: 'Cloud sourcePath allow test' }, { workspaceId: 'workspace-1' });
+            core.close();
+            const sourcePath = path.join(agentWorkspaceRoot, 'implementation-plan.md');
+            fs.writeFileSync(sourcePath, '# Recovered implementation plan', 'utf8');
+            process.env.TASKFORCE_ALLOWED_ATTACHMENT_SOURCE_ROOTS = agentWorkspaceRoot;
+            await callTool(projectRoot, 'cloud', 'save_task_attachment', {
+                id: task.id,
+                filename: 'implementation-plan.md',
+                sourcePath
+            });
+            const readBack = parseToolJson(await callTool(projectRoot, 'cloud', 'read_task_attachment', {
+                taskId: task.id,
+                attachmentId: parseToolJson(await callTool(projectRoot, 'cloud', 'get_task_attachments', { id: task.id })).attachments[0]?.attachmentId
+            }));
+            expect(readBack.content).toContain('# Recovered implementation plan');
+        }
+        finally {
+            if (previousRoots === undefined) {
+                delete process.env.TASKFORCE_ALLOWED_ATTACHMENT_SOURCE_ROOTS;
+            }
+            else {
+                process.env.TASKFORCE_ALLOWED_ATTACHMENT_SOURCE_ROOTS = previousRoots;
+            }
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+            fs.rmSync(agentWorkspaceRoot, { recursive: true, force: true });
+        }
+    });
+    it('rejects save_task_attachment sourcePath in cloud runtime for unapproved roots', async () => {
+        const projectRoot = createProjectRoot();
+        const externalRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-cloud-unapproved-'));
         try {
             const core = new TaskforceCore({
                 projectRoot,
@@ -1970,16 +2200,18 @@ describe('Taskforce MCP tool descriptions', () => {
             });
             const task = core.createTask({ title: 'Cloud sourcePath reject test' }, { workspaceId: 'workspace-1' });
             core.close();
+            const sourcePath = path.join(externalRoot, 'outside.md');
+            fs.writeFileSync(sourcePath, '# Outside approved roots', 'utf8');
             const result = await callTool(projectRoot, 'cloud', 'save_task_attachment', {
                 id: task.id,
-                filename: 'copy.txt',
-                sourcePath: 'docs/source.txt'
+                filename: 'outside.md',
+                sourcePath
             });
-            expect(result.content?.[0]?.text).toContain('does not support sourcePath for save_task_attachment yet');
-            expect(result.content?.[0]?.text).toContain('resend the attachment using inline content instead');
+            expect(result.content?.[0]?.text).toContain('sourcePath must be within project root, a Taskforce-managed attachment source, or an approved agent workspace root');
         }
         finally {
             fs.rmSync(projectRoot, { recursive: true, force: true });
+            fs.rmSync(externalRoot, { recursive: true, force: true });
         }
     });
     it('accepts task references for save_task_attachment', async () => {
@@ -2331,7 +2563,7 @@ describe('Taskforce MCP tool descriptions', () => {
                 filename: 'outside.md',
                 sourcePath: externalSourcePath
             });
-            expect(result.content?.[0]?.text).toContain('sourcePath must be within project root or a Taskforce-managed attachment source');
+            expect(result.content?.[0]?.text).toContain('sourcePath must be within project root, a Taskforce-managed attachment source, or an approved agent workspace root');
         }
         finally {
             fs.rmSync(projectRoot, { recursive: true, force: true });

package/dist/mcp/taskAttachmentHelpers.d.ts

@@ -0,0 +1,41 @@
+import type { WorkspaceAssetEntry, WorkspaceAssetKind, WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+import type { McpTaskAttachmentDescriptor, TaskAttachmentRecord } from './taskAttachmentTypes.js';
+export interface TaskAttachmentHelpersDeps {
+    activeWorkspaceId: string;
+    workspaceAssetStore: WorkspaceAssetStore | null;
+    getImageReferenceLabel: (asset: WorkspaceAssetEntry | null | undefined) => string | null;
+    getDocumentReferenceLabel: (asset: WorkspaceAssetEntry | null | undefined) => string | null;
+    inferMimeTypeFromPath: (filePath: string) => string;
+    inferAssetKind: (filePath: string, mimeType: string) => WorkspaceAssetKind;
+    isTextReadableMimeType: (mimeTypeRaw: string) => boolean;
+    isValidCanonicalDocumentAsset: (params: Pick<WorkspaceAssetEntry, 'kind' | 'storageKey' | 'originalFilename' | 'mimeType'>) => boolean;
+    canonicalAssetHelpers: {
+        getAttachmentAssetRecord: (attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null;
+        normalizeAttachmentStorageKey: (pathValue: unknown, fsPathValue: unknown) => string | null;
+        buildSyntheticAttachmentId: (taskId: string, attachment: TaskAttachmentRecord) => string;
+        toTaskAttachmentRecord: (attachment: string | TaskAttachmentRecord) => TaskAttachmentRecord;
+    };
+    documentHelpers: {
+        buildCanonicalDocumentAttachmentHint: (asset: {
+            assetId: string;
+            documentId: string | null;
+            referenceNumber?: number | null;
+            mimeType?: string | null;
+        }) => {
+            documentId: string | null;
+            preferredNextTool: string;
+            preferredWorkflow: string;
+            suggestedArgs: {
+                documentId: string;
+            };
+            guidance: string;
+        } | null;
+    };
+}
+export declare function createTaskAttachmentHelpers(deps: TaskAttachmentHelpersDeps): {
+    describeTaskAttachment: (taskId: string, attachmentInput: string | TaskAttachmentRecord) => McpTaskAttachmentDescriptor;
+    listTaskAttachmentDescriptors: (task: {
+        id: string;
+        attachments?: Array<string | TaskAttachmentRecord> | null;
+    }) => McpTaskAttachmentDescriptor[];
+};

package/dist/mcp/taskAttachmentHelpers.js

@@ -0,0 +1,60 @@
+export function createTaskAttachmentHelpers(deps) {
+    const isCanonicalDocumentAssetRecord = (asset) => deps.isValidCanonicalDocumentAsset(asset);
+    const describeTaskAttachment = (taskId, attachmentInput) => {
+        const attachment = deps.canonicalAssetHelpers.toTaskAttachmentRecord(attachmentInput);
+        const asset = deps.canonicalAssetHelpers.getAttachmentAssetRecord(attachment);
+        const storageKey = deps.canonicalAssetHelpers.normalizeAttachmentStorageKey(attachment.path, attachment.fsPath);
+        const assetId = String(attachment.assetId || asset?.assetId || '').trim() || undefined;
+        const source = (asset?.storageProvider === 'external' || /^https?:\/\//i.test(String(attachment.path || '').trim()))
+            ? 'external'
+            : 'canonical';
+        const mimeType = String(asset?.mimeType
+            || (storageKey && !/^https?:\/\//i.test(storageKey) ? deps.inferMimeTypeFromPath(storageKey) : '')
+            || deps.inferMimeTypeFromPath(String(attachment.originalFilename || attachment.displayName || attachment.caption || attachment.path || ''))).trim() || 'application/octet-stream';
+        const kind = asset?.kind || deps.inferAssetKind(storageKey || String(attachment.path || ''), mimeType);
+        const isCanonicalDocument = Boolean(asset && isCanonicalDocumentAssetRecord(asset)) || (!asset && kind === 'document');
+        const referenceNumber = typeof attachment.referenceNumber === 'number'
+            ? attachment.referenceNumber
+            : (typeof asset?.referenceNumber === 'number' ? asset.referenceNumber : null);
+        const referenceLabel = String(attachment.referenceLabel
+            || (kind === 'image' ? deps.getImageReferenceLabel(asset) : '')
+            || (isCanonicalDocument ? deps.getDocumentReferenceLabel(asset) : '')).trim() || null;
+        const readableAsText = source === 'canonical' && deps.isTextReadableMimeType(mimeType);
+        const canonicalDocumentHint = isCanonicalDocument && source === 'canonical' && asset
+            ? deps.documentHelpers.buildCanonicalDocumentAttachmentHint(asset)
+            : null;
+        return {
+            attachmentId: assetId || deps.canonicalAssetHelpers.buildSyntheticAttachmentId(taskId, attachment),
+            ...(assetId ? { assetId } : {}),
+            ...(referenceNumber ? { referenceNumber } : {}),
+            ...(referenceLabel ? { referenceLabel } : {}),
+            ...(canonicalDocumentHint?.documentId ? { documentId: canonicalDocumentHint.documentId } : {}),
+            path: String(attachment.path || '').trim(),
+            ...(storageKey && !/^https?:\/\//i.test(storageKey) ? { fsPath: storageKey } : (attachment.fsPath ? { fsPath: String(attachment.fsPath).trim() } : {})),
+            ...(attachment.caption ? { caption: String(attachment.caption).trim() } : {}),
+            ...(attachment.displayName ? { displayName: String(attachment.displayName).trim() } : {}),
+            ...(attachment.originalFilename ? { originalFilename: String(attachment.originalFilename).trim() } : {}),
+            kind: isCanonicalDocument ? 'document' : kind,
+            mimeType,
+            sizeBytes: asset ? Number(asset.sizeBytes || 0) : null,
+            ...(attachment.timestamp ? { timestamp: String(attachment.timestamp).trim() } : {}),
+            source,
+            readableAsText,
+            ...(canonicalDocumentHint ? {
+                preferredNextTool: canonicalDocumentHint.preferredNextTool,
+                preferredWorkflow: canonicalDocumentHint.preferredWorkflow,
+                suggestedArgs: canonicalDocumentHint.suggestedArgs,
+                guidance: canonicalDocumentHint.guidance,
+            } : {}),
+        };
+    };
+    const listTaskAttachmentDescriptors = (task) => {
+        if (!task || !Array.isArray(task.attachments))
+            return [];
+        return task.attachments.map((attachment) => describeTaskAttachment(task.id, attachment));
+    };
+    return {
+        describeTaskAttachment,
+        listTaskAttachmentDescriptors,
+    };
+}

package/dist/mcp/taskAttachmentTypes.d.ts

@@ -0,0 +1,37 @@
+import type { WorkspaceAssetKind } from '../storage/workspaceAssetStore.js';
+export type TaskAttachmentRecord = {
+    path: string;
+    fsPath?: string;
+    caption?: string;
+    displayName?: string;
+    originalFilename?: string;
+    timestamp?: string;
+    assetId?: string;
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+    taskId?: string | null;
+};
+export type McpTaskAttachmentDescriptor = {
+    attachmentId: string;
+    assetId?: string;
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+    documentId?: string | null;
+    path: string;
+    fsPath?: string;
+    caption?: string;
+    displayName?: string;
+    originalFilename?: string;
+    kind: WorkspaceAssetKind;
+    mimeType: string;
+    sizeBytes: number | null;
+    timestamp?: string;
+    source: 'canonical' | 'external';
+    readableAsText: boolean;
+    preferredNextTool?: string;
+    preferredWorkflow?: string;
+    suggestedArgs?: {
+        documentId: string;
+    };
+    guidance?: string;
+};

package/dist/mcp/taskAttachmentTypes.js

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

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;