@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/mcp/adminWorkspaceRegistrar.js

@@ -0,0 +1,154 @@
+import { bindDomainTool } from './toolCatalog.js';
+function stringProperty(description, enumValues) {
+    return enumValues ? { type: 'string', description, enum: enumValues } : { type: 'string', description };
+}
+function numberProperty(description) {
+    return { type: 'number', description };
+}
+function booleanProperty(description) {
+    return { type: 'boolean', description };
+}
+function arrayProperty(description, items) {
+    return { type: 'array', description, items };
+}
+export function registerAdminWorkspaceTools(registerTool, executeTool) {
+    const register = (name, buildDescriptor) => {
+        registerTool({
+            name,
+            buildDescriptor: (context) => {
+                const descriptor = buildDescriptor(context);
+                return {
+                    name,
+                    description: descriptor.description,
+                    inputSchema: {
+                        type: 'object',
+                        properties: descriptor.inputSchema.properties,
+                        ...(descriptor.inputSchema.required ? { required: descriptor.inputSchema.required } : {}),
+                    },
+                };
+            },
+            handler: bindDomainTool(executeTool, name),
+        });
+    };
+    register('get_config', (context) => ({
+        description: context.describeTool('Get the active workspace taxonomy and planning configuration. Call this at the start of a session or before create_task/update_task when you need valid category, type, priority, approach, status, or complexity values.'),
+        inputSchema: { properties: {} },
+    }));
+    register('update_categories', (context) => ({
+        description: context.describeTool('Replace the workspace category taxonomy. This is session-only and updates the active categories used by task fields and validation.'),
+        inputSchema: {
+            properties: {
+                categories: arrayProperty('Ordered category definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                        aliases: { type: 'array', items: { type: 'string' } },
+                    },
+                }),
+            },
+            required: ['categories'],
+        },
+    }));
+    register('update_types', (context) => ({
+        description: context.describeTool('Replace the workspace task type taxonomy. This is session-only and updates the active task type definitions used by validation and task editing flows.'),
+        inputSchema: {
+            properties: {
+                types: arrayProperty('Ordered task type definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                        aliases: { type: 'array', items: { type: 'string' } },
+                    },
+                }),
+            },
+            required: ['types'],
+        },
+    }));
+    register('bulk_update_type', (context) => ({
+        description: context.describeTool('Bulk-update tasks from one task type to another. Use get_config first to confirm the current valid type values.'),
+        inputSchema: {
+            properties: {
+                fromType: stringProperty('Current task type value to replace.', context.typeEnum),
+                toType: stringProperty('Replacement task type value.', context.typeEnum),
+            },
+            required: ['fromType', 'toType'],
+        },
+    }));
+    register('bulk_update_fields', (context) => ({
+        description: context.describeTool('Apply field updates to multiple tasks in one request. Use get_config first to confirm valid taxonomy values before calling this tool.'),
+        inputSchema: {
+            properties: {
+                updates: arrayProperty('List of per-task field updates.', {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Task ID or task reference such as T-123.' },
+                        title: { type: 'string' },
+                        description: { type: 'string' },
+                        category: { type: 'string' },
+                        type: { type: 'string' },
+                        priority: { type: 'number', description: context.priorityDesc },
+                        approach: { type: 'string', enum: context.approachEnum },
+                        assignee: { type: 'string', description: `${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.` },
+                        owner: { type: 'string', description: `${context.assigneeHint} Alias for assignee.` },
+                        status: { type: 'string', enum: ['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled'] },
+                        complexity: { type: 'number', description: context.complexityDesc },
+                    },
+                    required: ['id'],
+                }),
+            },
+            required: ['updates'],
+        },
+    }));
+    register('export_resources', (context) => ({
+        description: context.describeTool('Export Taskforce resources to files on disk. Local-only utility for generating external artifacts from workspace data.'),
+        inputSchema: {
+            properties: {
+                type: stringProperty('Resource export type.'),
+                path: stringProperty('Destination path for the export output.'),
+                variables: { type: 'object', description: 'Optional template variables for the export job.' },
+                environment: stringProperty('Optional environment name to include in the export context.'),
+            },
+            required: ['type', 'path'],
+        },
+    }));
+    register('get_paths', (context) => ({
+        description: context.describeTool('Get project and Taskforce storage paths. Local-only utility for discovering the project root, Taskforce data root, and related filesystem locations.'),
+        inputSchema: { properties: {} },
+    }));
+    register('update_priorities', (context) => ({
+        description: context.describeTool('Replace the workspace priority options. This is session-only and updates the valid priority taxonomy used by task editing flows.'),
+        inputSchema: {
+            properties: {
+                priorities: arrayProperty('Ordered priority definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'number' },
+                        label: { type: 'string' },
+                    },
+                }),
+            },
+            required: ['priorities'],
+        },
+    }));
+    register('update_approaches', (context) => ({
+        description: context.describeTool('Replace the active approach options. This is session-only and updates the valid approach taxonomy used by task editing flows.'),
+        inputSchema: {
+            properties: {
+                approaches: arrayProperty('Ordered approach definitions to save.', {
+                    type: 'object',
+                    properties: {
+                        value: { type: 'string' },
+                        label: { type: 'string' },
+                    },
+                }),
+            },
+            required: ['approaches'],
+        },
+    }));
+    register('get_stats', (context) => ({
+        description: context.describeTool('Get task counts by status and priority for situational awareness. Call this at the start of a session to understand the current workload before listing or modifying tasks. Returns active totals (by status and priority) and archived totals.'),
+        inputSchema: { properties: {} },
+    }));
+}

package/dist/mcp/collaborationRegistrar.d.ts

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

package/dist/mcp/collaborationRegistrar.js

@@ -0,0 +1,71 @@
+import { AI_PROFILE_SURFACE_TYPES } from '../shared/aiProfileSurfaceType.js';
+import { bindDomainTool } from './toolCatalog.js';
+function stringProperty(description) {
+    return { type: 'string', description };
+}
+export function registerCollaborationTools(registerTool, executeTool) {
+    const register = (name, buildDescriptor) => {
+        registerTool({
+            name,
+            buildDescriptor: (context) => {
+                const descriptor = buildDescriptor(context);
+                return {
+                    name,
+                    description: descriptor.description,
+                    inputSchema: {
+                        type: 'object',
+                        properties: descriptor.inputSchema.properties,
+                        ...(descriptor.inputSchema.required ? { required: descriptor.inputSchema.required } : {}),
+                    },
+                };
+            },
+            handler: bindDomainTool(executeTool, name),
+        });
+    };
+    register('list_assignees', (context) => ({
+        description: context.describeTool('List eligible assignees for the active workspace. Returns human workspace members and AI profiles that can own tasks. Use this before create_task, update_task, assign_task, or bulk_assign_tasks when you need a valid assignee ID.'),
+        inputSchema: { properties: {} },
+    }));
+    register('get_current_profile', (context) => ({
+        description: context.describeTool('Inspect the effective AI profile for this session. Use this when an agent needs to know its current profile id before filtering for tasks assigned to itself. If no profile is currently bound, this tool explains how to bootstrap with resolve_profile. You may also pass profileToken to inspect a stateless AI profile without mutating session state. The response includes the profileToken so automations can persist it after first bootstrap.'),
+        inputSchema: {
+            properties: {
+                profileToken: stringProperty('Optional AI profile token to inspect when no profile is currently bound in session state.'),
+            },
+        },
+    }));
+    register('resolve_profile', (context) => ({
+        description: context.describeTool('Resolve or create the current AI collaborator profile for this workspace. On first bootstrap, omit profileToken and Taskforce will create a named AI profile, issue a stable profileToken, and return the profile id to use in assignee, createdBy, and comment author fields on later calls. When a valid profileToken is provided, Taskforce resolves the existing profile and updates any supplied presentation fields such as name, icon, color, description, role, provider, model, and surfaceType. Update semantics: omitted optional fields leave existing stored values unchanged. For description, role, provider, and model, empty strings are ignored rather than clearing. For surfaceType, null or an empty string clears the stored value; valid enum values replace it.'),
+        inputSchema: {
+            properties: {
+                name: stringProperty('Display name for the AI collaborator.'),
+                icon: stringProperty('Optional icon name or emoji saved with the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                color: stringProperty('Optional profile color saved with the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                description: stringProperty('Optional short description stored on the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                role: stringProperty('Optional role label stored on the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                provider: stringProperty('Optional provider name stored as secondary diagnostic metadata on the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                model: stringProperty('Optional model name stored as secondary diagnostic metadata on the AI profile. Omit to leave unchanged when profileToken is provided.'),
+                surfaceType: {
+                    anyOf: [
+                        { type: 'string', enum: [...AI_PROFILE_SURFACE_TYPES] },
+                        { type: 'null' },
+                    ],
+                    description: 'Optional self-declared AI surface type. Use agent for a persistent named AI collaborator in Taskforce, coding_tool for the coding surface or terminal tool itself, chat_app for a conversational app identity, ide for an IDE-native copilot identity, and other only when none of those fit. If you are unsure and you are registering a named collaborator such as a teammate-style AI persona, choose agent. Omit to leave unchanged; pass null or an empty string to clear.',
+                },
+                profileToken: stringProperty('Previously issued Taskforce profile token. When provided, Taskforce resolves the existing profile instead of creating a new one, and applies any supplied presentation field updates to that profile.'),
+            },
+            required: ['name'],
+        },
+    }));
+    register('add_comment', (context) => ({
+        description: context.describeTool('Add a comment to a task. Use this for agent progress notes, handoff summaries, decision logs, and audit trails. Comments are visible in the task timeline.'),
+        inputSchema: {
+            properties: {
+                id: stringProperty('Task ID or task reference such as T-123.'),
+                text: stringProperty('Comment text.'),
+                author: stringProperty('Comment author identity. Use your AI profile id from resolve_profile, or use user for human-authored comments.'),
+            },
+            required: ['id', 'text', 'author'],
+        },
+    }));
+}

package/dist/mcp/documentAssetRegistrar.d.ts

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

package/dist/mcp/documentAssetRegistrar.js

@@ -0,0 +1,346 @@
+import { bindDomainTool } from './toolCatalog.js';
+function stringProperty(description, enumValues) {
+    return enumValues ? { type: 'string', description, enum: enumValues } : { type: 'string', description };
+}
+function numberProperty(description) {
+    return { type: 'number', description };
+}
+function booleanProperty(description) {
+    return { type: 'boolean', description };
+}
+function arrayProperty(description, items) {
+    return { type: 'array', description, items };
+}
+export function registerDocumentAssetTools(registerTool, executeTool) {
+    const register = (name, buildDescriptor) => {
+        registerTool({
+            name,
+            buildDescriptor: (context) => {
+                const descriptor = buildDescriptor(context);
+                return {
+                    name,
+                    description: descriptor.description,
+                    inputSchema: {
+                        type: 'object',
+                        properties: descriptor.inputSchema.properties,
+                        ...(descriptor.inputSchema.required ? { required: descriptor.inputSchema.required } : {}),
+                    },
+                };
+            },
+            handler: bindDomainTool(executeTool, name),
+        });
+    };
+    register('get_task_attachments', (context) => ({
+        description: context.describeTool('List attachment descriptors for one task. This returns metadata only; use read_task_attachment for file contents. For canonical documents, prefer get_document and read_document_content for the document-focused workflow.'),
+        inputSchema: {
+            properties: {
+                taskId: stringProperty('Task ID or task reference such as T-123.'),
+            },
+            required: ['taskId'],
+        },
+    }));
+    register('read_task_attachment', (context) => ({
+        description: context.describeTool('Read one task attachment by attachmentId. Prefer this tool over opening attachment path URLs directly. For a canonical document attachment, this response also points toward the document-specific workflow.'),
+        inputSchema: {
+            properties: {
+                taskId: stringProperty('Task ID or task reference such as T-123.'),
+                attachmentId: stringProperty('Attachment descriptor id from get_task_attachments.'),
+                maxChars: numberProperty('Optional max inline character count for readable text attachments.'),
+            },
+            required: ['taskId', 'attachmentId'],
+        },
+    }));
+    register('search_images', (context) => ({
+        description: context.describeTool('Search image assets by keyword, title, filename, caption, or I-123 reference. Use this before get_image when you only know a rough identifier.'),
+        inputSchema: {
+            properties: {
+                query: stringProperty('Search term for image lookup, including I-123 references.'),
+                limit: numberProperty('Max images to return.'),
+            },
+            required: ['query'],
+        },
+    }));
+    register('get_image', (context) => ({
+        description: context.describeTool('Get a single image by asset id or image reference such as I-123. Use this first when the user references an image, then use get_annotated_attachment_sessions and read_annotated_attachment_payload for annotation details. When the image is being used for UI, placement, or visual correction feedback, read the saved annotation payload before making changes.'),
+        inputSchema: {
+            properties: {
+                id: stringProperty('Image asset id or image reference such as I-123.'),
+            },
+            required: ['id'],
+        },
+    }));
+    register('search_documents', (context) => ({
+        description: context.describeTool('Search document assets by keyword, title, filename, caption, or D-123 reference. Use this before get_document when you only know a rough identifier. Search results guide the next step into get_document and read_document_content.'),
+        inputSchema: {
+            properties: {
+                query: stringProperty('Search term for document lookup, including D-123 references.'),
+                limit: numberProperty('Max documents to return.'),
+            },
+            required: ['query'],
+        },
+    }));
+    register('get_document', (context) => ({
+        description: context.describeTool('Get a single canonical document by asset id or document reference such as D-123. Use this first when the user references a document, then call read_document_content to inspect what it is reviewing.'),
+        inputSchema: {
+            properties: {
+                id: stringProperty('Document asset id or document reference such as D-123.'),
+            },
+            required: ['id'],
+        },
+    }));
+    register('read_document_content', (context) => ({
+        description: context.describeTool('Read the canonical document body for one document. Use this when an AI needs to inspect what it is reviewing before adding review comments.'),
+        inputSchema: {
+            properties: {
+                documentId: stringProperty('Document asset id or document reference such as D-123.'),
+                maxChars: numberProperty('Optional max inline character count for readable documents.'),
+            },
+            required: ['documentId'],
+        },
+    }));
+    register('get_annotated_attachment_sessions', (context) => ({
+        description: context.describeTool('List saved annotation sessions for one image. Use this after get_image when you need the saved annotation sessions before opening one payload. If the user is pointing at a visual target in I-123, do not stop at the screenshot alone; inspect the saved session payload next.'),
+        inputSchema: {
+            properties: {
+                imageId: stringProperty('Image asset id or image reference such as I-123.'),
+            },
+            required: ['imageId'],
+        },
+    }));
+    register('read_annotated_attachment_payload', (context) => ({
+        description: context.describeTool('Read the structured payload for one annotated attachment session, including markers, geometry, and derived crop hints. Use this as the authoritative instruction source when I-123 is being used for UI placement or visual change requests.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+            },
+            required: ['sessionId'],
+        },
+    }));
+    register('create_annotated_attachment_session', (context) => ({
+        description: context.describeTool('Create a new annotation session for one image. Use this before adding markers when no saved session exists yet.'),
+        inputSchema: {
+            properties: {
+                imageId: stringProperty('Image asset id or image reference such as I-123.'),
+                title: stringProperty('Optional session title.'),
+            },
+            required: ['imageId'],
+        },
+    }));
+    register('update_annotated_attachment_session', (context) => ({
+        description: context.describeTool('Update an existing annotation session without changing its marker list directly.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                title: stringProperty('Updated session title.'),
+            },
+            required: ['sessionId'],
+        },
+    }));
+    register('delete_annotated_attachment_session', (context) => ({
+        description: context.describeTool('Delete an annotated attachment session when the whole session was created by mistake, rather than deleting markers one by one.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+            },
+            required: ['sessionId'],
+        },
+    }));
+    register('review_image', (context) => ({
+        description: context.describeTool('Run a first-pass visual review workflow for one image and save the result into an annotation session when appropriate.'),
+        inputSchema: {
+            properties: {
+                imageId: stringProperty('Image asset id or image reference such as I-123.'),
+                prompt: stringProperty('Review instructions or focus areas for the first-pass review.'),
+            },
+            required: ['imageId', 'prompt'],
+        },
+    }));
+    register('add_annotated_attachment_marker', (context) => ({
+        description: context.describeTool('Add one marker to an annotation session using normalized 0..1 coordinates.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                type: stringProperty('Marker type.'),
+                x: numberProperty('Normalized x coordinate in the 0..1 range.'),
+                y: numberProperty('Normalized y coordinate in the 0..1 range.'),
+                width: numberProperty('Optional normalized width in the 0..1 range.'),
+                height: numberProperty('Optional normalized height in the 0..1 range.'),
+                text: stringProperty('Optional marker text or note.'),
+            },
+            required: ['sessionId', 'type', 'x', 'y'],
+        },
+    }));
+    register('bulk_add_annotated_attachment_markers', (context) => ({
+        description: context.describeTool('Add multiple markers to one annotation session in a single request. Useful for batch import after a first-pass review.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                markers: arrayProperty('Marker definitions to add.', {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string' },
+                        x: { type: 'number' },
+                        y: { type: 'number' },
+                        width: { type: 'number' },
+                        height: { type: 'number' },
+                        text: { type: 'string' },
+                    },
+                    required: ['type', 'x', 'y'],
+                }),
+            },
+            required: ['sessionId', 'markers'],
+        },
+    }));
+    register('update_annotated_attachment_marker', (context) => ({
+        description: context.describeTool('Update one existing annotation marker without recreating it.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                markerId: stringProperty('Marker id within the session.'),
+                type: stringProperty('Updated marker type.'),
+                x: numberProperty('Updated normalized x coordinate.'),
+                y: numberProperty('Updated normalized y coordinate.'),
+                width: numberProperty('Updated normalized width.'),
+                height: numberProperty('Updated normalized height.'),
+                text: stringProperty('Updated marker text.'),
+            },
+            required: ['sessionId', 'markerId'],
+        },
+    }));
+    register('reorder_annotated_attachment_marker', (context) => ({
+        description: context.describeTool('Move one marker within the session review order.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                markerId: stringProperty('Marker id within the session.'),
+                order: numberProperty('Target zero-based review order.'),
+            },
+            required: ['sessionId', 'markerId', 'order'],
+        },
+    }));
+    register('delete_annotated_attachment_marker', (context) => ({
+        description: context.describeTool('Delete one marker from an annotation session.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Annotated attachment session id.'),
+                markerId: stringProperty('Marker id within the session.'),
+            },
+            required: ['sessionId', 'markerId'],
+        },
+    }));
+    register('get_document_review_sessions', (context) => ({
+        description: context.describeTool('List review sessions for one document such as D-123. Use read_document_content first when you need to inspect the document body before choosing a session.'),
+        inputSchema: {
+            properties: {
+                documentId: stringProperty('Document asset id or document reference such as D-123.'),
+            },
+            required: ['documentId'],
+        },
+    }));
+    register('get_document_review_session', (context) => ({
+        description: context.describeTool('Get one document review session with its comments and summary state.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Document review session id.'),
+            },
+            required: ['sessionId'],
+        },
+    }));
+    register('create_document_review_session', (context) => ({
+        description: context.describeTool('Create a new document review session. Requires AI identity via resolve_profile before write operations.'),
+        inputSchema: {
+            properties: {
+                documentId: stringProperty('Document asset id or document reference such as D-123.'),
+                title: stringProperty('Optional review session title.'),
+            },
+            required: ['documentId'],
+        },
+    }));
+    register('update_document_review_session', (context) => ({
+        description: context.describeTool('Update a document review session title, status, or summary fields without creating a new session. Requires AI identity via resolve_profile before write operations.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Document review session id.'),
+                title: stringProperty('Updated review session title.'),
+                status: stringProperty('Updated review status.'),
+                summary: stringProperty('Updated review summary.'),
+            },
+            required: ['sessionId'],
+        },
+    }));
+    register('review_document', (context) => ({
+        description: context.describeTool('Run the lower-friction document review path for one document. This helper creates or updates the review workflow while preserving a lower-friction document review path than manual session management. Requires AI identity via resolve_profile before write operations.'),
+        inputSchema: {
+            properties: {
+                documentId: stringProperty('Document asset id or document reference such as D-123.'),
+                prompt: stringProperty('Review instructions or focus areas.'),
+            },
+            required: ['documentId', 'prompt'],
+        },
+    }));
+    register('add_document_review_comment', (context) => ({
+        description: context.describeTool('Add a comment to a document review session. Use this for review feedback that should stay attached to the document rather than the task. Requires AI identity via resolve_profile before write operations.'),
+        inputSchema: {
+            properties: {
+                sessionId: stringProperty('Document review session id.'),
+                body: stringProperty('Comment text.'),
+                anchor: { type: 'object', description: 'Optional anchor object such as a quote or line-range reference.' },
+            },
+            required: ['sessionId', 'body'],
+        },
+    }));
+    register('update_document_review_comment', (context) => ({
+        description: context.describeTool('Update an existing document review comment without creating a new comment.'),
+        inputSchema: {
+            properties: {
+                commentId: stringProperty('Document review comment id.'),
+                body: stringProperty('Updated comment text.'),
+            },
+            required: ['commentId', 'body'],
+        },
+    }));
+    register('delete_document_review_comment', (context) => ({
+        description: context.describeTool('Delete an existing document review comment when it should be removed entirely.'),
+        inputSchema: {
+            properties: {
+                commentId: stringProperty('Document review comment id.'),
+            },
+            required: ['commentId'],
+        },
+    }));
+    register('link_task_context', (context) => ({
+        description: context.describeTool('Attach an external http(s) URL as task context. link_task_context only supports an external http(s) URL; use save_task_attachment for files or generated content.'),
+        inputSchema: {
+            properties: {
+                id: stringProperty('Task ID or task reference such as T-123.'),
+                path: stringProperty('External http(s) URL to attach.'),
+                caption: stringProperty('Optional caption for the linked context entry.'),
+            },
+            required: ['id', 'path'],
+        },
+    }));
+    register('save_task_attachment', (context) => ({
+        description: context.describeTool('Save a file and attach it to a task. Use this for generated content or existing files from disk. Set overwrite=true to replace an existing canonical attachment with the same filename. For AI-authored markdown/text, use inline content for AI-authored markdown/text rather than writing an external temp file first.'),
+        inputSchema: {
+            properties: {
+                id: stringProperty('Task ID or task reference such as T-123.'),
+                filename: stringProperty('Destination filename for the attachment.'),
+                content: stringProperty('Inline file content; use this for AI-authored markdown/text attachments.'),
+                sourcePath: stringProperty('Path to an existing source file. Must be within project root, a Taskforce-managed attachment source, or an approved agent workspace root.'),
+                caption: stringProperty('Optional attachment caption.'),
+                overwrite: booleanProperty('When true, overwrite an existing canonical task attachment with the same filename instead of creating a new one.'),
+            },
+            required: ['id', 'filename'],
+        },
+    }));
+    register('delete_task_attachment', (context) => ({
+        description: context.describeTool('Delete one task attachment. Use get_task_attachments first to inspect attachment ids before removing one.'),
+        inputSchema: {
+            properties: {
+                taskId: stringProperty('Task ID or task reference such as T-123.'),
+                attachmentId: stringProperty('Attachment descriptor id from get_task_attachments.'),
+            },
+            required: ['taskId', 'attachmentId'],
+        },
+    }));
+}

package/dist/mcp/runtime.d.ts

@@ -2,6 +2,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { McpAccessTokenScope, TaskforceCore } from '../core/Taskforce.js';
 import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
+import { type AiProfileSeatScope } from '../shared/aiProfileSeatScope.js';
 export interface TaskforceMcpServerOptions {
     projectRoot?: string;
     tenantId?: string;
@@ -23,6 +24,7 @@ export interface TaskforceMcpServerOptions {
         aiProfileProvider?: AiProfileBootstrapConfig['aiProfileProvider'];
         aiProfileModel?: AiProfileBootstrapConfig['aiProfileModel'];
         aiProfileSurfaceType?: AiProfileBootstrapConfig['aiProfileSurfaceType'];
+        aiProfileSeatScope?: AiProfileSeatScope | null;
         actorType?: 'local' | 'user' | 'token' | 'oauth';
         requestId?: string | null;
         ip?: string | null;