@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/localization/locales/en-US.js

@@ -1,11 +1,12 @@
 export const enUS = {
     taskForm: {
         commentsSectionTitle: 'Activity & Comments',
-        hideComments: 'Hide Comments',
-        showComments: 'Show Comments',
         noComments: 'No comments yet. Start the conversation!',
+        noActivity: 'No activity yet.',
         you: 'You',
         commentPlaceholder: 'Type a comment...',
+        newActivity: 'New activity',
+        newActivityAriaLabel: 'New activity. Scroll to latest.',
         scheduledLabel: 'Scheduled:',
         dueLabel: 'Due:',
         createdLabel: 'Created:',
@@ -78,7 +79,6 @@ export const enUS = {
         groupType: 'Type',
         groupPriority: 'Priority',
         groupComplexity: 'Complexity',
-        groupApproach: 'Workflow',
         groupAssignee: 'Assignee',
         groupStatus: 'Status',
         groupHierarchy: 'Hierarchy',

package/dist/localization/locales/es-419.js

@@ -1,11 +1,12 @@
 export const es419 = {
     taskForm: {
         commentsSectionTitle: 'Actividad y comentarios',
-        hideComments: 'Ocultar comentarios',
-        showComments: 'Mostrar comentarios',
         noComments: 'Aun no hay comentarios. Inicia la conversacion.',
+        noActivity: 'Aun no hay actividad.',
         you: 'Tu',
         commentPlaceholder: 'Escribe un comentario...',
+        newActivity: 'Nueva actividad',
+        newActivityAriaLabel: 'Nueva actividad. Ir a la mas reciente.',
         scheduledLabel: 'Programado:',
         dueLabel: 'Vence:',
         createdLabel: 'Creado:',
@@ -78,7 +79,6 @@ export const es419 = {
         groupType: 'Tipo',
         groupPriority: 'Prioridad',
         groupComplexity: 'Complejidad',
-        groupApproach: 'Flujo de trabajo',
         groupAssignee: 'Asignado a',
         groupStatus: 'Estado',
         groupHierarchy: 'Jerarquia',

package/dist/localization/locales/pt-BR.js

@@ -1,11 +1,12 @@
 export const ptBR = {
     taskForm: {
         commentsSectionTitle: 'Atividade e comentarios',
-        hideComments: 'Ocultar comentarios',
-        showComments: 'Mostrar comentarios',
         noComments: 'Ainda nao ha comentarios. Inicie a conversa.',
+        noActivity: 'Ainda nao ha atividade.',
         you: 'Voce',
         commentPlaceholder: 'Digite um comentario...',
+        newActivity: 'Nova atividade',
+        newActivityAriaLabel: 'Nova atividade. Ir para a mais recente.',
         scheduledLabel: 'Agendado:',
         dueLabel: 'Vencimento:',
         createdLabel: 'Criado:',
@@ -78,7 +79,6 @@ export const ptBR = {
         groupType: 'Tipo',
         groupPriority: 'Prioridade',
         groupComplexity: 'Complexidade',
-        groupApproach: 'Fluxo de trabalho',
         groupAssignee: 'Atribuido para',
         groupStatus: 'Status',
         groupHierarchy: 'Hierarquia',

package/dist/mcp/adminWorkspaceRegistrar.js

@@ -31,7 +31,7 @@ export function registerAdminWorkspaceTools(registerTool, executeTool) {
         });
     };
     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.'),
+        description: context.describeTool('Get the active workspace taxonomy and planning configuration. Task write schemas already include current taxonomy values; call this when you need richer labels and metadata or after a taxonomy validation mismatch.'),
         inputSchema: { properties: {} },
     }));
     register('update_categories', (context) => ({
@@ -79,7 +79,6 @@ export function registerAdminWorkspaceTools(registerTool, executeTool) {
                         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'] },
@@ -91,18 +90,6 @@ export function registerAdminWorkspaceTools(registerTool, executeTool) {
             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: {} },
@@ -122,23 +109,8 @@ export function registerAdminWorkspaceTools(registerTool, executeTool) {
             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.'),
+        description: context.describeTool('Get task counts by status and priority for situational awareness. Returns active totals, archived done/cancelled totals, and Trash totals separately. Archived tasks are retained; Trash records are recoverable for 90 days before automatic permanent deletion.'),
         inputSchema: { properties: {} },
     }));
 }

package/dist/mcp/aiProfileBootstrap.d.ts

@@ -1,7 +1,9 @@
 import type { IncomingHttpHeaders } from 'http';
 import type { ResolveAiProfileInput } from '../core/Taskforce.js';
 import { type AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { type McpClientId } from './clientRegistry.js';
 export interface AiProfileBootstrapConfig {
+    mcpClientId?: McpClientId | null;
     aiProfileToken?: string | null;
     aiProfileName?: string | null;
     aiProfileIcon?: string | null;
@@ -13,6 +15,7 @@ export interface AiProfileBootstrapConfig {
     aiProfileSurfaceType?: AiProfileSurfaceType | null;
 }
 export declare const AI_PROFILE_BOOTSTRAP_HEADER_NAMES: {
+    readonly mcpClientId: "X-Taskforce-MCP-Client-ID";
     readonly aiProfileToken: "X-Taskforce-AI-Profile-Token";
     readonly aiProfileName: "X-Taskforce-AI-Name";
     readonly aiProfileIcon: "X-Taskforce-AI-Icon";

package/dist/mcp/aiProfileBootstrap.js

@@ -1,5 +1,7 @@
 import { parseAiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+import { parseMcpClientId } from './clientRegistry.js';
 export const AI_PROFILE_BOOTSTRAP_HEADER_NAMES = {
+    mcpClientId: 'X-Taskforce-MCP-Client-ID',
     aiProfileToken: 'X-Taskforce-AI-Profile-Token',
     aiProfileName: 'X-Taskforce-AI-Name',
     aiProfileIcon: 'X-Taskforce-AI-Icon',
@@ -21,6 +23,7 @@ function normalizeBootstrapSurfaceType(value) {
 }
 export function normalizeAiProfileBootstrapConfig(input) {
     return {
+        mcpClientId: parseMcpClientId(input.mcpClientId),
         aiProfileToken: normalizeBootstrapValue(input.aiProfileToken),
         aiProfileName: normalizeBootstrapValue(input.aiProfileName),
         aiProfileIcon: normalizeBootstrapValue(input.aiProfileIcon),
@@ -50,6 +53,7 @@ export function parseAiProfileBootstrapHeaders(headers) {
         return normalizeBootstrapValue(value);
     };
     return {
+        mcpClientId: parseMcpClientId(readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.mcpClientId)),
         aiProfileToken: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileToken),
         aiProfileName: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileName),
         aiProfileIcon: readHeader(AI_PROFILE_BOOTSTRAP_HEADER_NAMES.aiProfileIcon),

package/dist/mcp/canonicalAssetHelpers.d.ts

@@ -1,16 +1,24 @@
-import type { WorkspaceAssetEntry, WorkspaceAssetKind, WorkspaceAssetLinkRole, WorkspaceAssetLinkTargetType, WorkspaceAssetScanStatus, WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+import type { WorkspaceAssetEntry, WorkspaceAssetKind, WorkspaceAssetLinkRole, WorkspaceAssetLinkTargetType, WorkspaceAssetScanStatus, WorkspaceAssetStore, WorkspaceDocumentEntry } from '../storage/workspaceAssetStore.js';
+import { type WorkspaceSyncPublishedContentResolver } from '../sync/engine/workspaceSyncPublishedContentResolver.js';
 import type { McpTaskAttachmentDescriptor, TaskAttachmentRecord } from './taskAttachmentTypes.js';
 export interface CanonicalAssetHelpersDeps {
     activeWorkspaceId: string;
     projectRoot: string;
     basePath: string;
     workspaceAssetStore: WorkspaceAssetStore | null;
+    tenantId?: string;
+    publishedContentResolver?: Pick<WorkspaceSyncPublishedContentResolver, 'resolve'> | null;
     objectStorageClient: {
         getObject(storageKey: string): Promise<{
             body: Buffer;
         } | null>;
         putObject?(storageKey: string, body: Buffer, contentType: string): Promise<void>;
     } | null;
+    publishContentVersion?: (input: {
+        asset: WorkspaceAssetEntry;
+        body: Buffer;
+        sourceUpdatedAt: string;
+    }) => Promise<void>;
     sanitizeFilenameForPath: (filenameRaw: unknown, fallback?: string) => string;
     sanitizeDisplayName: (valueRaw: unknown, fallback: string) => string;
     toPosixPath: (filePath: string) => string;
@@ -20,6 +28,7 @@ export interface CanonicalAssetHelpersDeps {
         workspaceIdRaw: unknown;
         kind: WorkspaceAssetKind;
         filename: string;
+        assetId?: string;
         now?: Date;
     }) => {
         relativePath: string;
@@ -31,15 +40,15 @@ export declare function createCanonicalAssetHelpers(deps: CanonicalAssetHelpersD
     buildSyntheticAttachmentId: (taskId: string, attachment: TaskAttachmentRecord) => string;
     getAttachmentAssetRecord: (attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null;
     buildAttachmentDownloadUrl: (attachment: McpTaskAttachmentDescriptor) => string;
-    buildDocumentDownloadUrl: (asset: WorkspaceAssetEntry) => string;
+    buildDocumentDownloadUrl: (asset: WorkspaceAssetEntry | WorkspaceDocumentEntry) => string;
     readCanonicalAttachmentBuffer: (taskId: string, attachment: McpTaskAttachmentDescriptor, targetLabel?: string) => Promise<Buffer>;
-    readCanonicalDocumentBuffer: (asset: WorkspaceAssetEntry) => Promise<Buffer>;
+    readCanonicalDocumentBuffer: (asset: WorkspaceAssetEntry | WorkspaceDocumentEntry) => Promise<Buffer>;
     toTaskAttachmentRecord: (attachment: string | TaskAttachmentRecord) => TaskAttachmentRecord;
     resolveAttachmentLogicalFilename: (attachmentInput: string | TaskAttachmentRecord, assetOverride?: ReturnType<(attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null> | null) => string;
     resolveCanonicalOverwriteTarget: (task: {
         id: string;
         attachments?: Array<string | TaskAttachmentRecord> | null;
-    }, filenameRaw: unknown, describeTaskAttachment: (taskId: string, attachmentInput: string | TaskAttachmentRecord) => McpTaskAttachmentDescriptor) => null | {
+    }, filenameRaw: unknown, describeTaskAttachment: (taskId: string, attachmentInput: string | TaskAttachmentRecord) => McpTaskAttachmentDescriptor, assetIdRaw?: unknown) => null | {
         index: number;
         attachment: TaskAttachmentRecord;
         asset: NonNullable<ReturnType<(attachment: TaskAttachmentRecord) => WorkspaceAssetEntry | null>>;
@@ -58,6 +67,7 @@ export declare function createCanonicalAssetHelpers(deps: CanonicalAssetHelpersD
         scanStatus?: WorkspaceAssetScanStatus;
         scanEngine?: string | null;
         scanDetails?: string | null;
+        createLink?: boolean;
     }) => Promise<WorkspaceAssetEntry | null>;
     ensureCanonicalTaskAttachment: (relativePathRaw: string, taskIdRaw: string, captionRaw: string | undefined, timestampRaw: string | undefined, role: WorkspaceAssetLinkRole, options?: Parameters<(relativePathRaw: string, targetTypeRaw: WorkspaceAssetLinkTargetType, targetIdRaw: string, captionRaw: string | undefined, timestampRaw: string | undefined, role: WorkspaceAssetLinkRole, options?: {
         originalFilename?: string;
@@ -69,11 +79,13 @@ export declare function createCanonicalAssetHelpers(deps: CanonicalAssetHelpersD
         scanStatus?: WorkspaceAssetScanStatus;
         scanEngine?: string | null;
         scanDetails?: string | null;
+        createLink?: boolean;
     }) => Promise<WorkspaceAssetEntry | null>>[6]) => Promise<WorkspaceAssetEntry | null>;
     buildCanonicalWorkspaceAssetRelativePath: (params: {
         workspaceIdRaw: unknown;
         kind: WorkspaceAssetKind;
         filename: string;
+        assetId?: string;
         now?: Date;
     }) => {
         relativePath: string;

package/dist/mcp/canonicalAssetHelpers.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash, randomUUID } from 'node:crypto';
+import { verifyWorkspaceSyncPublishedContentBody, } from '../sync/engine/workspaceSyncPublishedContentResolver.js';
 import { normalizeRelativeStorageKey, resolveExistingStorageKeyFilePathInsideRoot, resolveStorageKeyWritePathInsideRoot } from '../utils/pathSafety.js';
 export function createCanonicalAssetHelpers(deps) {
     const normalizeAttachmentStorageKey = (pathValue, fsPathValue) => {
@@ -26,6 +27,29 @@ export function createCanonicalAssetHelpers(deps) {
     const resolveCanonicalLocalFilePath = (storageKey) => {
         return resolveExistingStorageKeyFilePathInsideRoot(deps.basePath, storageKey);
     };
+    const resolveCanonicalContentRead = (asset, kind) => {
+        if (!deps.publishedContentResolver) {
+            return {
+                source: 'legacy',
+                physicalKey: asset.storageKey,
+                storageProvider: asset.storageProvider,
+            };
+        }
+        const tenantId = String(deps.tenantId || '').trim();
+        if (!tenantId) {
+            throw new Error('Canonical content read failed because the tenant scope is unavailable.');
+        }
+        if (asset.storageProvider !== 'local' && asset.storageProvider !== 'r2') {
+            throw new Error(`Canonical content ${asset.assetId} uses an unsupported storage provider.`);
+        }
+        return deps.publishedContentResolver.resolve({
+            tenantId,
+            workspaceId: deps.activeWorkspaceId,
+            kind,
+            logicalPath: asset.storageKey,
+            legacyProvider: asset.storageProvider,
+        });
+    };
     const buildSyntheticAttachmentId = (taskId, attachment) => {
         const stableSource = [
             taskId,
@@ -61,7 +85,7 @@ export function createCanonicalAssetHelpers(deps) {
     };
     const buildDocumentDownloadUrl = (asset) => {
         const safeName = deps.sanitizeFilenameForPath(asset.originalFilename
-            || asset.logicalName
+            || ('title' in asset ? asset.title : asset.logicalName)
             || path.basename(String(asset.storageKey || '').trim())
             || 'document.txt', 'document.txt');
         return `/api/taskforce/documents/${encodeURIComponent(String(asset.assetId || '').trim())}/content?download=1&filename=${encodeURIComponent(safeName)}`;
@@ -88,32 +112,40 @@ export function createCanonicalAssetHelpers(deps) {
         if (asset.scanStatus === 'pending') {
             throw new Error('Attachment scan pending');
         }
-        if (asset.storageProvider === 'r2') {
-            if (!normalizeRelativeStorageKey(asset.storageKey)) {
+        const resolved = resolveCanonicalContentRead(asset, asset.kind === 'document' ? 'document' : 'asset');
+        if (resolved.source === 'deleted') {
+            throw new Error(`Attachment ${attachment.attachmentId} not found on ${targetLabel} ${taskId}`);
+        }
+        if (resolved.storageProvider === 'r2') {
+            if (!normalizeRelativeStorageKey(resolved.physicalKey)) {
                 throw new Error(`Attachment ${attachment.attachmentId} not found on ${targetLabel} ${taskId}`);
             }
-            const attachmentContext = describeAttachmentStorageContext(attachment, asset.storageKey);
+            const attachmentContext = describeAttachmentStorageContext(attachment, resolved.physicalKey);
             if (!deps.objectStorageClient) {
                 throw new Error(`Attachment read failed from R2 because object storage is not configured in this MCP runtime (${attachmentContext})`);
             }
             let object;
             try {
-                object = await deps.objectStorageClient.getObject(asset.storageKey);
+                object = await deps.objectStorageClient.getObject(resolved.physicalKey);
             }
-            catch (error) {
-                const message = error instanceof Error ? String(error.message || '').trim() : String(error || '').trim();
-                throw new Error(`Attachment read failed from R2 (${attachmentContext}): ${message || 'Unknown object storage error'}`);
+            catch {
+                throw new Error(`Attachment read failed from R2 (${attachmentContext})`);
             }
             if (!object) {
                 throw new Error(`Attachment ${attachment.attachmentId} not found on ${targetLabel} ${taskId}`);
             }
-            return object.body;
+            return resolved.source === 'versioned'
+                ? verifyWorkspaceSyncPublishedContentBody(object.body, resolved, `Attachment ${attachment.attachmentId}`)
+                : object.body;
         }
-        const resolvedPath = resolveCanonicalLocalFilePath(asset.storageKey);
+        const resolvedPath = resolveCanonicalLocalFilePath(resolved.physicalKey);
         if (!resolvedPath) {
             throw new Error(`Attachment ${attachment.attachmentId} not found on ${targetLabel} ${taskId}`);
         }
-        return fs.readFileSync(resolvedPath);
+        const body = fs.readFileSync(resolvedPath);
+        return resolved.source === 'versioned'
+            ? verifyWorkspaceSyncPublishedContentBody(body, resolved, `Attachment ${attachment.attachmentId}`)
+            : body;
     };
     const readCanonicalDocumentBuffer = async (asset) => {
         if (asset.deletedAt || asset.kind !== 'document') {
@@ -125,31 +157,39 @@ export function createCanonicalAssetHelpers(deps) {
         if (asset.scanStatus === 'pending') {
             throw new Error('Document scan pending');
         }
-        if (asset.storageProvider === 'r2') {
-            if (!normalizeRelativeStorageKey(asset.storageKey)) {
+        const resolved = resolveCanonicalContentRead(asset, 'document');
+        if (resolved.source === 'deleted') {
+            throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
+        }
+        if (resolved.storageProvider === 'r2') {
+            if (!normalizeRelativeStorageKey(resolved.physicalKey)) {
                 throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
             }
             if (!deps.objectStorageClient) {
-                throw new Error(`Document read failed from R2 because object storage is not configured in this MCP runtime (assetId=${asset.assetId}, storageKey=${asset.storageKey || 'unknown'})`);
+                throw new Error(`Document read failed from R2 because object storage is not configured in this MCP runtime (assetId=${asset.assetId}, storageKey=${resolved.physicalKey || 'unknown'})`);
             }
             let object;
             try {
-                object = await deps.objectStorageClient.getObject(asset.storageKey);
+                object = await deps.objectStorageClient.getObject(resolved.physicalKey);
             }
-            catch (error) {
-                const message = error instanceof Error ? String(error.message || '').trim() : String(error || '').trim();
-                throw new Error(`Document read failed from R2 (assetId=${asset.assetId}, storageKey=${asset.storageKey || 'unknown'}): ${message || 'Unknown object storage error'}`);
+            catch {
+                throw new Error(`Document read failed from R2 (assetId=${asset.assetId}, storageKey=${resolved.physicalKey || 'unknown'})`);
             }
             if (!object) {
                 throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
             }
-            return object.body;
+            return resolved.source === 'versioned'
+                ? verifyWorkspaceSyncPublishedContentBody(object.body, resolved, `Document ${asset.assetId}`)
+                : object.body;
         }
-        const resolvedPath = resolveCanonicalLocalFilePath(asset.storageKey);
+        const resolvedPath = resolveCanonicalLocalFilePath(resolved.physicalKey);
         if (!resolvedPath) {
             throw new Error(`Document ${asset.assetId} not found in workspace ${deps.activeWorkspaceId}.`);
         }
-        return fs.readFileSync(resolvedPath);
+        const body = fs.readFileSync(resolvedPath);
+        return resolved.source === 'versioned'
+            ? verifyWorkspaceSyncPublishedContentBody(body, resolved, `Document ${asset.assetId}`)
+            : body;
     };
     const toTaskAttachmentRecord = (attachment) => {
         if (typeof attachment === 'string') {
@@ -171,8 +211,9 @@ export function createCanonicalAssetHelpers(deps) {
         const storageKey = normalizeAttachmentStorageKey(attachment.path, attachment.fsPath);
         return deps.sanitizeFilenameForPath(storageKey ? path.basename(storageKey) : '', 'attachment.txt');
     };
-    const resolveCanonicalOverwriteTarget = (task, filenameRaw, describeTaskAttachment) => {
+    const resolveCanonicalOverwriteTarget = (task, filenameRaw, describeTaskAttachment, assetIdRaw) => {
         const requestedFilename = deps.sanitizeFilenameForPath(filenameRaw);
+        const requestedAssetId = String(assetIdRaw || '').trim();
         const existingAttachments = Array.isArray(task.attachments) ? task.attachments : [];
         for (let index = 0; index < existingAttachments.length; index++) {
             const attachment = toTaskAttachmentRecord(existingAttachments[index]);
@@ -183,7 +224,7 @@ export function createCanonicalAssetHelpers(deps) {
             if (descriptor.source !== 'canonical')
                 continue;
             const logicalFilename = resolveAttachmentLogicalFilename(attachment, asset);
-            if (logicalFilename !== requestedFilename)
+            if (requestedAssetId ? asset.assetId !== requestedAssetId : logicalFilename !== requestedFilename)
                 continue;
             const absolutePath = resolveStorageKeyWritePathInsideRoot(deps.basePath, asset.storageKey);
             if (!absolutePath)
@@ -227,6 +268,23 @@ export function createCanonicalAssetHelpers(deps) {
         }
         const originalFilename = deps.sanitizeFilenameForPath(options?.originalFilename || existing?.originalFilename || path.basename(relativePath));
         const logicalName = deps.sanitizeDisplayName(options?.logicalName || existing?.logicalName || originalFilename, originalFilename);
+        const contentSha256 = createHash('sha256').update(buffer).digest('hex');
+        const documentContentUnchanged = kind === 'document'
+            && !!existing
+            && (!options?.assetId || options.assetId === existing.assetId)
+            && existing.contentSha256 === contentSha256;
+        const publishedContentMatches = !deps.publishContentVersion || (() => {
+            if (!existing || kind !== 'document')
+                return false;
+            try {
+                const resolved = resolveCanonicalContentRead(existing, 'document');
+                return resolved.source === 'versioned'
+                    && resolved.contentSha256 === contentSha256;
+            }
+            catch {
+                return false;
+            }
+        })();
         const asset = deps.workspaceAssetStore.upsertAsset({
             assetId: options?.assetId || existing?.assetId || `asset-${randomUUID().replace(/-/g, '')}`,
             workspaceId: deps.activeWorkspaceId,
@@ -236,10 +294,12 @@ export function createCanonicalAssetHelpers(deps) {
             mimeType,
             storageProvider: shouldPersistToObjectStorage ? 'r2' : 'local',
             storageKey,
-            contentSha256: createHash('sha256').update(buffer).digest('hex'),
+            contentSha256,
             sizeBytes: stats.size,
             documentId: kind === 'document' ? (options?.documentId || existing?.documentId || `doc-${randomUUID().replace(/-/g, '')}`) : null,
-            version: kind === 'document' ? Math.max(1, Number(existing?.version || 0) + 1) : null,
+            version: kind === 'document'
+                ? Math.max(1, Number(existing?.version || 0) + (documentContentUnchanged ? 0 : 1))
+                : null,
             isLatest: true,
             scanStatus: options?.scanStatus || existing?.scanStatus || 'clean',
             scanEngine: options?.scanEngine !== undefined ? options.scanEngine : (existing?.scanEngine || null),
@@ -250,16 +310,25 @@ export function createCanonicalAssetHelpers(deps) {
             deletedAt: null,
             purgeAfter: null
         });
-        deps.workspaceAssetStore.upsertLink({
-            workspaceId: deps.activeWorkspaceId,
-            assetId: asset.assetId,
-            targetType,
-            targetId,
-            role,
-            displayName: kind === 'document' ? null : (captionRaw || null),
-            updatedAt: timestamp,
-            deletedAt: null
-        });
+        if (!documentContentUnchanged || !publishedContentMatches) {
+            await deps.publishContentVersion?.({
+                asset,
+                body: buffer,
+                sourceUpdatedAt: timestamp,
+            });
+        }
+        if (options?.createLink !== false) {
+            deps.workspaceAssetStore.upsertLink({
+                workspaceId: deps.activeWorkspaceId,
+                assetId: asset.assetId,
+                targetType,
+                targetId,
+                role,
+                displayName: kind === 'document' ? null : (captionRaw || null),
+                updatedAt: timestamp,
+                deletedAt: null
+            });
+        }
         return asset;
     };
     const ensureCanonicalTaskAttachment = (relativePathRaw, taskIdRaw, captionRaw, timestampRaw, role, options) => ensureCanonicalAttachment(relativePathRaw, 'task', taskIdRaw, captionRaw, timestampRaw, role, options);

package/dist/mcp/clientIntegrations.d.ts

@@ -1,5 +1,6 @@
-import { type AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
-export type McpClientId = 'general' | 'cursor' | 'cline' | 'vscode' | 'kiro' | 'windsurf' | 'antigravity' | 'openclaw' | 'codex' | 'grok' | 'claude-code' | 'gemini-cli' | 'claude-desktop' | 'chatgpt-desktop';
+import type { AiProfileBootstrapConfig } from './aiProfileBootstrap.js';
+import { type McpClientId } from './clientRegistry.js';
+export type { McpClientId } from './clientRegistry.js';
 export interface McpClientOption {
     id: McpClientId;
     label: string;
@@ -32,6 +33,7 @@ export interface CloudMcpClientIntegration {
     renderedText?: string;
 }
 export declare function buildLocalAiProfileEnv(clientId: McpClientId): Record<string, string>;
+export declare function buildMcpConnectionId(...parts: Array<string | null | undefined>): string;
 export declare const MCP_CLIENT_OPTIONS: McpClientOption[];
 export declare function sanitizeMcpId(value: string, fallback: string): string;
 export declare function buildCloudMcpServerId(workspaceName?: string | null, projectName?: string | null): string;