@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/mcp/runtime.js

@@ -6,6 +6,7 @@ import * as path from 'path';
 import { createHash, randomUUID } from 'node:crypto';
 import { TaskforceCore, TaskforceRuleError } from '../core/Taskforce.js'; // Note .js extension for ESM
 import { COMPLEXITY_OPTIONS, resolveNumberOption, resolveStringOption, STATUS_OPTIONS } from './optionResolution.js';
+import { buildResolveAiProfileInputFromBootstrap } from './aiProfileBootstrap.js';
 import { validateStructuredDocForAttach } from './structuredDocValidation.js';
 import { validateStructuredCommentForAdd } from './structuredCommentValidation.js';
 import { resolveDatabaseConfigFromEnv } from '../storage/providerConfig.js';
@@ -16,9 +17,9 @@ import { ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } fr
 import { getDocumentReferenceLabel, parseDocumentReference } from '../utils/documentReferences.js';
 import { getImageReferenceLabel, parseImageReference } from '../utils/imageReferences.js';
 import { inferCanonicalAssetKind, isValidCanonicalDocumentAsset } from '../utils/canonicalAssetKind.js';
+import { getTaskReferenceLabel, shouldUseProvisionalTaskReferences } from '../utils/taskReferences.js';
 import { AI_PROFILE_SURFACE_TYPES, parseAiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
 import { formatWorkstreamReference, resolveInitiativeReference, parseWorkstreamReference, } from '../utils/planningReferences.js';
-import { getTaskReferenceLabel } from '../utils/taskReferences.js';
 import { MCP_TOOL_PERMISSIONS, MCP_WRITE_TOOL_NAMES } from './toolRegistry.js';
 export function isMcpWriteToolName(name) {
     return MCP_WRITE_TOOL_NAMES.has(String(name || '').trim());
@@ -71,7 +72,7 @@ function resolveRecoverableToolError(error) {
             code: 'AI_PROFILE_REQUIRED',
             nextTool: 'resolve_profile',
             suggestedArgs: {},
-            retryHint: 'Call resolve_profile, store the returned profileToken, and pass profileToken on later mutating calls if the client is stateless.'
+            retryHint: 'Call get_current_profile to inspect binding state first, or call resolve_profile to bind an AI identity. Only pass profileToken on later mutating calls if your client is stateless.'
         };
     }
     if (/^Invalid AI profile token\./i.test(message)) {
@@ -80,7 +81,7 @@ function resolveRecoverableToolError(error) {
             code: 'INVALID_AI_PROFILE_TOKEN',
             nextTool: 'resolve_profile',
             suggestedArgs: {},
-            retryHint: 'Call resolve_profile again to obtain a fresh profileToken, then retry the original mutating tool call.'
+            retryHint: 'Call get_current_profile to confirm whether ambient identity is already bound. If not, call resolve_profile again to obtain a fresh profileToken, then retry the original mutating tool call.'
         };
     }
     if (error instanceof TaskforceRuleError) {
@@ -586,7 +587,7 @@ export function createTaskforceMcpServer(options = {}) {
             },
             tools: {},
         },
-        instructions: `You are an AI collaborator connected to Taskforce, a shared task management system for AI-developer pairs.\n\nIMPORTANT: At the start of any session, call resolve_profile before attempting any mutating Taskforce tools. Pass your name and a profileToken if you received one in a previous session. Store the returned profileToken for reuse across sessions. Use the returned profile id as the assignee or author on tasks and comments you create.\n\nStateless client pattern: call resolve_profile, save the returned profileToken, and include profileToken on later mutating tool calls if your MCP client does not preserve session identity between calls.\n\nAutomation-friendly connection pattern: if your MCP connection is configured with x-taskforce-ai-name and optionally x-taskforce-ai-profile-token headers, Taskforce can auto-bind that AI identity for get_current_profile and later writes without requiring profileToken on every tool call.\n\nWhen setting resolve_profile.surfaceType, classify yourself by the kind of identity you are registering: 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.\n\nTo get tasks assigned to yourself, call get_current_profile, then use the returned suggestedArgs with list_tasks. When you begin active work on a tracked task, prefer start_task. It sets the task to in-progress and claims it for your AI profile when the task is currently unassigned. When work on a tracked task is complete, prefer finish_task for the final handoff: use outcome='review' when the next step is human validation or approval, and use outcome='done' only when no explicit human action is requested. Do not leave a task in-progress after reporting completed implementation unless the user explicitly wants more work to continue in the same task.\n\nTaxonomy rule: always call get_config before setting category, type, priority, approach, status, or complexity. Do not rely on remembered enum values.\n\nUse identifier prefixes to choose the correct retrieval path: T-123 goes to task tools such as get_task, IN-123 goes to initiative tools such as get_initiative, WS-123 goes to workstream tools such as get_workstream, I-123 goes to image tools such as get_image, and D-123 goes to document tools such as get_document. Do not send I-123 or D-123 identifiers to get_task.\n\nFor annotated images, use search_images first when you know only a keyword, filename, or rough title. Once you have the exact identifier, call get_image, then use get_annotated_attachment_sessions to list saved sessions, then use read_annotated_attachment_payload for the structured annotation payload.\n\nFor documents, use search_documents first when you know only a keyword, filename, or rough title. Once you have the exact identifier, call get_document, then read_document_content to inspect the document body. For a lower-friction review flow, prefer review_document; otherwise use get_document_review_sessions or create_document_review_session, then add_document_review_comment to record review feedback.`,
+        instructions: `You are an AI collaborator connected to Taskforce, a shared task management system for AI-developer pairs.\n\nIMPORTANT: Before mutating Taskforce data, ensure Taskforce knows which AI profile you are acting as. The preferred path is ambient session binding: if your MCP connection is configured with x-taskforce-ai-name and optionally x-taskforce-ai-profile-token headers, Taskforce can auto-bind that AI identity for get_current_profile and later writes. If no AI identity is currently bound, call resolve_profile with your name. Reuse the returned profileToken across sessions, especially for stateless clients.\n\nStateless client pattern: call resolve_profile, save the returned profileToken, and include profileToken on later mutating tool calls only when your MCP client does not preserve session identity between calls.\n\nTo inspect your current attribution state before writes, call get_current_profile. It reports whether identity is bound, how it was resolved, and the suggested args to use with list_tasks.\n\nWhen setting resolve_profile.surfaceType, classify yourself by the kind of identity you are registering: 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.\n\nTo get tasks assigned to yourself, call get_current_profile, then use the returned suggestedArgs with list_tasks. When you begin active work on a tracked task, prefer start_task. It sets the task to in-progress and claims it for your AI profile when the task is currently unassigned. When work on a tracked task is complete, prefer finish_task for the final handoff: use outcome='review' when the next step is human validation or approval, and use outcome='done' only when no explicit human action is requested. Do not leave a task in-progress after reporting completed implementation unless the user explicitly wants more work to continue in the same task.\n\nTaxonomy rule: always call get_config before setting category, type, priority, approach, status, or complexity. Do not rely on remembered enum values.\n\nUse identifier prefixes to choose the correct retrieval path: T-123 goes to task tools such as get_task, IN-123 goes to initiative tools such as get_initiative, WS-123 goes to workstream tools such as get_workstream, I-123 goes to image tools such as get_image, and D-123 goes to document tools such as get_document. Do not send I-123 or D-123 identifiers to get_task.\n\nFor annotated images, use search_images first when you know only a keyword, filename, or rough title. Once you have the exact identifier, call get_image, then use get_annotated_attachment_sessions to list saved sessions, then use read_annotated_attachment_payload for the structured annotation payload.\n\nFor documents, use search_documents first when you know only a keyword, filename, or rough title. Once you have the exact identifier, call get_document, then read_document_content to inspect the document body. For a lower-friction review flow, prefer review_document; otherwise use get_document_review_sessions or create_document_review_session, then add_document_review_comment to record review feedback.`,
     });
     const TOOL_PERMISSIONS = MCP_TOOL_PERMISSIONS;
     const RESOURCE_PERMISSIONS = {
@@ -923,6 +924,8 @@ export function createTaskforceMcpServer(options = {}) {
     const auditTokenId = options.auth?.tokenId ? String(options.auth.tokenId).trim() : null;
     const configuredAiProfileToken = options.auth?.aiProfileToken ? String(options.auth.aiProfileToken).trim() || null : null;
     const configuredAiProfileName = options.auth?.aiProfileName ? String(options.auth.aiProfileName).trim() || null : null;
+    const configuredAiProfileIcon = options.auth?.aiProfileIcon ? String(options.auth.aiProfileIcon).trim() || null : null;
+    const configuredAiProfileColor = options.auth?.aiProfileColor ? String(options.auth.aiProfileColor).trim() || null : null;
     const configuredAiProfileDescription = options.auth?.aiProfileDescription ? String(options.auth.aiProfileDescription).trim() || null : null;
     const configuredAiProfileRole = options.auth?.aiProfileRole ? String(options.auth.aiProfileRole).trim() || null : null;
     const configuredAiProfileProvider = options.auth?.aiProfileProvider ? String(options.auth.aiProfileProvider).trim() || null : null;
@@ -932,6 +935,7 @@ export function createTaskforceMcpServer(options = {}) {
     const auditIp = options.auth?.ip ? String(options.auth.ip).trim() || null : null;
     const auditUserAgent = options.auth?.userAgent ? String(options.auth.userAgent).trim() || null : null;
     let activeAiProfileId = null;
+    let activeAiBindingSource = null;
     function getEligibleAssigneeActors() {
         return core.listAssignableActors(ACTIVE_WORKSPACE_ID)
             .filter((actor) => String(actor.id || '').trim().toLowerCase() !== 'agent')
@@ -1084,20 +1088,24 @@ export function createTaskforceMcpServer(options = {}) {
         const token = String(args.profileToken || '').trim();
         return token || null;
     }
+    function getCurrentAiBindingSource() {
+        if (!activeAiProfileId)
+            return 'none';
+        return activeAiBindingSource || 'session';
+    }
     function buildConfiguredAiProfileResolveInput(includeToken = true) {
-        if (!configuredAiProfileName)
-            return null;
         const configuredSurfaceType = parseAiProfileSurfaceType(configuredAiProfileSurfaceType);
-        return {
-            workspaceId: ACTIVE_WORKSPACE_ID,
-            name: configuredAiProfileName,
-            ...(includeToken && configuredAiProfileToken ? { profileToken: configuredAiProfileToken } : {}),
-            ...(configuredAiProfileDescription ? { description: configuredAiProfileDescription } : {}),
-            ...(configuredAiProfileRole ? { role: configuredAiProfileRole } : {}),
-            ...(configuredAiProfileProvider ? { provider: configuredAiProfileProvider } : {}),
-            ...(configuredAiProfileModel ? { model: configuredAiProfileModel } : {}),
-            ...(configuredSurfaceType ? { surfaceType: configuredSurfaceType } : {}),
-        };
+        return buildResolveAiProfileInputFromBootstrap(ACTIVE_WORKSPACE_ID, {
+            aiProfileToken: configuredAiProfileToken,
+            aiProfileName: configuredAiProfileName,
+            aiProfileIcon: configuredAiProfileIcon,
+            aiProfileColor: configuredAiProfileColor,
+            aiProfileDescription: configuredAiProfileDescription,
+            aiProfileRole: configuredAiProfileRole,
+            aiProfileProvider: configuredAiProfileProvider,
+            aiProfileModel: configuredAiProfileModel,
+            aiProfileSurfaceType: configuredSurfaceType,
+        }, includeToken);
     }
     function ensureResolvedProfileFromConnection(defaults) {
         if (activeAiProfileId)
@@ -1110,6 +1118,7 @@ export function createTaskforceMcpServer(options = {}) {
                 try {
                     const resolved = core.resolveAiProfile(configuredResolveInput);
                     activeAiProfileId = resolved.profile.id;
+                    activeAiBindingSource = 'connection_bootstrap';
                     return;
                 }
                 catch {
@@ -1122,6 +1131,7 @@ export function createTaskforceMcpServer(options = {}) {
             });
             if (profile) {
                 activeAiProfileId = profile.id;
+                activeAiBindingSource = 'connection_bootstrap';
                 return;
             }
             if (!allowCreateFromName || !configuredAiProfileName) {
@@ -1131,6 +1141,7 @@ export function createTaskforceMcpServer(options = {}) {
         if (allowCreateFromName && configuredResolveFallbackInput) {
             const resolved = core.resolveAiProfile(configuredResolveFallbackInput);
             activeAiProfileId = resolved.profile.id;
+            activeAiBindingSource = 'connection_bootstrap';
         }
     }
     function ensureResolvedProfileForTool(name, args) {
@@ -1151,6 +1162,7 @@ export function createTaskforceMcpServer(options = {}) {
         });
         if (profile) {
             activeAiProfileId = profile.id;
+            activeAiBindingSource = 'token_lookup';
             return;
         }
         const configuredResolveInput = buildConfiguredAiProfileResolveInput(false);
@@ -1158,6 +1170,7 @@ export function createTaskforceMcpServer(options = {}) {
             try {
                 const resolved = core.resolveAiProfile(configuredResolveInput);
                 activeAiProfileId = resolved.profile.id;
+                activeAiBindingSource = 'connection_bootstrap';
                 return;
             }
             catch {
@@ -1651,7 +1664,7 @@ export function createTaskforceMcpServer(options = {}) {
             console.error(`[Taskforce MCP] Failed to send resources/updated for ${uri}: ${error.message}`);
         }
     }
-    async function notifyResourceMutation(options) {
+    function collectResourceMutationUris(options) {
         const uris = new Set();
         if (options.includeConfig)
             uris.add(RESOURCE_CONFIG_URI);
@@ -1678,10 +1691,39 @@ export function createTaskforceMcpServer(options = {}) {
                 uris.add(workstreamUriFor(workstreamId));
             }
         }
+        return uris;
+    }
+    const pendingResourceInvalidations = new Set();
+    let resourceInvalidationFlushHandle = null;
+    function scheduleResourceInvalidationFlush() {
+        if (resourceInvalidationFlushHandle)
+            return;
+        resourceInvalidationFlushHandle = setTimeout(() => {
+            resourceInvalidationFlushHandle = null;
+            void flushScheduledResourceInvalidations();
+        }, 0);
+    }
+    async function flushScheduledResourceInvalidations() {
+        if (pendingResourceInvalidations.size === 0)
+            return;
+        const uris = Array.from(pendingResourceInvalidations);
+        pendingResourceInvalidations.clear();
         for (const uri of uris) {
             await notifyResourceUpdatedIfSubscribed(uri);
         }
     }
+    function scheduleResourceMutation(options) {
+        const uris = collectResourceMutationUris(options);
+        if (uris.size === 0)
+            return;
+        for (const uri of uris) {
+            pendingResourceInvalidations.add(uri);
+        }
+        scheduleResourceInvalidationFlush();
+    }
+    async function notifyResourceMutation(options) {
+        scheduleResourceMutation(options);
+    }
     function buildConfigResourcePayload() {
         return {
             project: {
@@ -1703,13 +1745,26 @@ export function createTaskforceMcpServer(options = {}) {
         };
     }
     function buildTasksResourcePayload() {
-        const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks;
+        const tasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks
+            .map((task) => buildPlanningTaskSummary(task));
         return {
             total: tasks.length,
             tasks,
         };
     }
-    function listHistoricalWorkspaceTasks() {
+    function buildPlanningTaskSummary(task) {
+        const { description, comments, taskEvents, activity, createdByActor, assigneeActor, attachments, checklistItems, ...rest } = task;
+        return rest;
+    }
+    function buildPlanningWorkstreamSummary(workstream) {
+        const { description, taskIds, ...rest } = workstream;
+        return rest;
+    }
+    function buildPlanningInitiativeSummary(initiative) {
+        const { description, ...rest } = initiative;
+        return rest;
+    }
+    function buildHistoricalWorkspaceTaskSnapshot() {
         const activeTasks = core.listTasks(ACTIVE_WORKSPACE_ID).tasks;
         const archivedTasks = core.listArchive(ACTIVE_WORKSPACE_ID).archived;
         const byId = new Map();
@@ -1717,40 +1772,70 @@ export function createTaskforceMcpServer(options = {}) {
             byId.set(task.id, task);
         for (const task of archivedTasks)
             byId.set(task.id, task);
-        return Array.from(byId.values());
+        const tasks = Array.from(byId.values());
+        const tasksByWorkstreamId = new Map();
+        for (const task of tasks) {
+            const normalizedWorkstreamId = String(task.workstreamId || '').trim();
+            if (!normalizedWorkstreamId)
+                continue;
+            const current = tasksByWorkstreamId.get(normalizedWorkstreamId) || [];
+            current.push(buildPlanningTaskSummary(task));
+            tasksByWorkstreamId.set(normalizedWorkstreamId, current);
+        }
+        return {
+            tasks,
+            tasksByWorkstreamId,
+        };
     }
-    function buildInitiativeResourcePayload(initiative) {
-        const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID)
-            .filter((workstream) => workstream.initiativeId === initiative.id);
-        const tasks = listHistoricalWorkspaceTasks()
-            .filter((task) => workstreams.some((workstream) => workstream.id === task.workstreamId));
+    function buildInitiativeResourcePayload(initiative, options) {
+        const tasksByWorkstreamId = options?.tasksByWorkstreamId || buildHistoricalWorkspaceTaskSnapshot().tasksByWorkstreamId;
+        const workstreams = options?.workstreamsByInitiativeId?.get(initiative.id)
+            || core.listWorkstreams(ACTIVE_WORKSPACE_ID)
+                .filter((workstream) => workstream.initiativeId === initiative.id);
+        const tasks = workstreams.flatMap((workstream) => tasksByWorkstreamId.get(workstream.id) || []);
         return {
-            initiative,
+            initiative: buildPlanningInitiativeSummary(initiative),
             workstreamCount: workstreams.length,
             taskCount: tasks.length,
-            workstreams,
+            workstreams: workstreams.map((workstream) => buildPlanningWorkstreamSummary(workstream)),
         };
     }
-    function buildWorkstreamResourcePayload(workstream) {
-        const tasks = listHistoricalWorkspaceTasks()
-            .filter((task) => task.workstreamId === workstream.id);
+    function buildWorkstreamResourcePayload(workstream, options) {
+        const tasksByWorkstreamId = options?.tasksByWorkstreamId || buildHistoricalWorkspaceTaskSnapshot().tasksByWorkstreamId;
+        const tasks = tasksByWorkstreamId.get(workstream.id)
+            || [];
         return {
-            workstream,
+            workstream: buildPlanningWorkstreamSummary(workstream),
             taskCount: tasks.length,
             tasks,
         };
     }
     function buildInitiativesResourcePayload() {
+        const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID);
+        const workstreamsByInitiativeId = new Map();
+        for (const workstream of workstreams) {
+            const normalizedInitiativeId = String(workstream.initiativeId || '').trim();
+            if (!normalizedInitiativeId)
+                continue;
+            const current = workstreamsByInitiativeId.get(normalizedInitiativeId) || [];
+            current.push(workstream);
+            workstreamsByInitiativeId.set(normalizedInitiativeId, current);
+        }
+        const { tasksByWorkstreamId } = buildHistoricalWorkspaceTaskSnapshot();
         const initiatives = core.listInitiatives(ACTIVE_WORKSPACE_ID)
-            .map((initiative) => buildInitiativeResourcePayload(initiative));
+            .map((initiative) => buildInitiativeResourcePayload(initiative, {
+            workstreamsByInitiativeId,
+            tasksByWorkstreamId,
+        }));
         return {
             total: initiatives.length,
             initiatives,
         };
     }
     function buildWorkstreamsResourcePayload() {
+        const { tasksByWorkstreamId } = buildHistoricalWorkspaceTaskSnapshot();
         const workstreams = core.listWorkstreams(ACTIVE_WORKSPACE_ID)
-            .map((workstream) => buildWorkstreamResourcePayload(workstream));
+            .map((workstream) => buildWorkstreamResourcePayload(workstream, { tasksByWorkstreamId }));
         return {
             total: workstreams.length,
             workstreams,
@@ -2038,8 +2123,8 @@ export function createTaskforceMcpServer(options = {}) {
                     type: "object",
                     properties: {
                         name: { type: "string", description: "Display name for the AI collaborator." },
-                        icon: { type: "string", description: "Optional icon name or emoji saved with the AI profile." },
-                        color: { type: "string", description: "Optional profile color saved with the AI profile." },
+                        icon: { type: "string", description: "Optional icon name or emoji saved with the AI profile. Omit to leave unchanged when profileToken is provided." },
+                        color: { type: "string", description: "Optional profile color saved with the AI profile. Omit to leave unchanged when profileToken is provided." },
                         description: { type: "string", description: "Optional short description stored on the AI profile. Omit to leave unchanged when profileToken is provided." },
                         role: { type: "string", description: "Optional role label stored on the AI profile. Omit to leave unchanged when profileToken is provided." },
                         provider: { type: "string", description: "Optional provider name stored as secondary diagnostic metadata on the AI profile. Omit to leave unchanged when profileToken is provided." },
@@ -3217,18 +3302,7 @@ export function createTaskforceMcpServer(options = {}) {
                     }
                 }
             };
-        }).filter((tool) => {
-            if (!hasPermission(TOOL_PERMISSIONS[tool.name]))
-                return false;
-            const taskforceToolsEnv = process.env.TASKFORCE_TOOLS;
-            if (taskforceToolsEnv) {
-                const enabledTools = taskforceToolsEnv.split(',').map(t => t.trim()).filter(Boolean);
-                if (enabledTools.length > 0 && !enabledTools.includes(tool.name)) {
-                    return false;
-                }
-            }
-            return true;
-        });
+        }).filter((tool) => hasPermission(TOOL_PERMISSIONS[tool.name]));
         return {
             tools,
         };
@@ -3311,6 +3385,7 @@ export function createTaskforceMcpServer(options = {}) {
                         profileToken: typeof profileToken === 'string' ? profileToken : null
                     });
                     activeAiProfileId = resolved.profile.id;
+                    activeAiBindingSource = 'session';
                     recordMcpWriteAudit('resolve_profile', {
                         profileId: resolved.profile.id,
                         created: resolved.created
@@ -3358,6 +3433,7 @@ export function createTaskforceMcpServer(options = {}) {
                     let profile = activeAiProfileId
                         ? core.listAiProfiles(ACTIVE_WORKSPACE_ID).find((entry) => entry.id === activeAiProfileId) || null
                         : null;
+                    let bindingSource = getCurrentAiBindingSource();
                     if (!profile && typeof profileToken === 'string' && profileToken.trim()) {
                         profile = core.getAiProfileByToken({
                             workspaceId: ACTIVE_WORKSPACE_ID,
@@ -3366,6 +3442,7 @@ export function createTaskforceMcpServer(options = {}) {
                         if (!profile) {
                             throw new Error('Invalid AI profile token. Call resolve_profile again and retry.');
                         }
+                        bindingSource = 'token_lookup';
                     }
                     return {
                         content: [{
@@ -3373,6 +3450,8 @@ export function createTaskforceMcpServer(options = {}) {
                                 text: JSON.stringify({
                                     workspaceId: ACTIVE_WORKSPACE_ID,
                                     identityBound: Boolean(activeAiProfileId),
+                                    bindingSource,
+                                    writeReady: Boolean(profile),
                                     profileToken: profile?.profileToken ?? null,
                                     profile: profile ? buildAiProfileDescriptor(profile) : null,
                                     taskFilter: profile ? { assignee: profile.id } : null,
@@ -4779,7 +4858,11 @@ export function createTaskforceMcpServer(options = {}) {
                             ...createArgs,
                             ...normalized,
                             createdBy: getActiveMcpCreatedBy()
-                        }, { workspaceId: ACTIVE_WORKSPACE_ID, actorRef: getActiveMcpActorRef() });
+                        }, {
+                            workspaceId: ACTIVE_WORKSPACE_ID,
+                            actorRef: getActiveMcpActorRef(),
+                            provisionalLocalReference: shouldUseProvisionalTaskReferences(runtimeMode)
+                        });
                         recordMcpWriteAudit('create_task', {
                             taskId: task?.id || null,
                             title: task?.title || null