chore: bump version to v0.4.21

Aperçu du contenu source pour les fichiers texte/Markdown (.md, .txt, .csv, .json, .xml) avec bouton Copier (presse-papier + toast) et téléchargement. Détection par MIME ou extension, chargement via getContent. Icône Markdown dédiée dans la liste.

config/services.yaml

@@ -45,6 +45,10 @@ services:
         arguments:
             $uploadDir: '%task_document_upload_dir%'
 
+    App\Mcp\Tool\Task\AddTaskDocumentTool:
+        arguments:
+            $uploadDir: '%task_document_upload_dir%'
+
     App\Controller\UserAvatarController:
         arguments:
             $avatarUploadDir: '%avatar_upload_dir%'

config/version.yaml

@@ -1,2 +1,2 @@
 parameters:
-    app.version: '0.4.10'
+    app.version: '0.4.21'

frontend/assets/css/app.css

@@ -0,0 +1,21 @@
+/*
+ * App-level layout fixes (not theme-related).
+ */
+
+/*
+ * MalioDrawer : donne au corps scrollable un peu d'espace vertical.
+ *
+ * Le body du drawer est `overflow-y-auto` sans padding vertical. Or le label
+ * flottant d'un champ Malio remonte (-1.25rem) au focus/remplissage : pour le
+ * PREMIER champ, collé en haut du body, ce label dépasse le bord supérieur et
+ * se fait rogner (il « grossit et passe sous l'entête »). Le dernier champ
+ * (popover de date, hint) souffre du même rognage en bas.
+ *
+ * On ajoute donc un padding vertical au body de TOUS les drawers via l'API de
+ * test stable de la lib (@malio/layer-ui), sans la modifier ni toucher chaque
+ * drawer un par un. Le sélecteur reste limité au panneau du drawer.
+ */
+[data-test="panel"] > [data-test="body"] {
+    padding-top: 1rem;
+    padding-bottom: 1rem;
+}

frontend/components/absence/AbsenceBalanceCards.vue

@@ -102,7 +102,8 @@ const others = computed<AbsenceBalance[]>(() =>
 )
 
 function formatNumber(n: number): string {
-    return (Math.round(n * 2) / 2).toString()
+    // Valeur réelle avec décimales (ex. 8,75) : pas d'arrondi qui gonflerait le solde.
+    return new Intl.NumberFormat('fr-FR', { maximumFractionDigits: 2 }).format(n)
 }
 
 // Total entitlement = acquired (N-1) + in-progress (N); falls back to the

frontend/components/absence/EmployeeDrawer.vue

@@ -7,16 +7,22 @@
             </div>
         </template>
         <form v-if="user" class="grid grid-cols-1 gap-4 sm:grid-cols-2" @submit.prevent="save">
-            <MalioDate
-                v-model="form.hireDate"
-                :label="$t('absences.admin.employees.fields.hireDate')"
-                group-class="w-full"
-            />
-            <MalioDate
-                v-model="form.endDate"
-                :label="$t('absences.admin.employees.fields.endDate')"
-                group-class="w-full"
-            />
+            <!-- Dates en pleine largeur (1 par ligne) : le popover du calendrier
+                 a besoin de toute la largeur pour s'afficher correctement. -->
+            <div class="sm:col-span-2">
+                <MalioDate
+                    v-model="form.hireDate"
+                    :label="$t('absences.admin.employees.fields.hireDate')"
+                    group-class="w-full"
+                />
+            </div>
+            <div class="sm:col-span-2">
+                <MalioDate
+                    v-model="form.endDate"
+                    :label="$t('absences.admin.employees.fields.endDate')"
+                    group-class="w-full"
+                />
+            </div>
             <MalioSelect
                 v-model="form.contractType"
                 :label="$t('absences.admin.employees.fields.contractType')"

frontend/components/task/TaskBulkActions.vue

@@ -79,6 +79,17 @@
                 @update:model-value="(v: number | null) => v && emit('bulk-update', 'group', v)"
             />
 
+            <!-- Archive (only when current filter targets a final status) -->
+            <MalioButtonIcon
+                v-if="canArchive"
+                icon="mdi:archive-outline"
+                aria-label="Archiver"
+                variant="ghost"
+                icon-size="22"
+                button-class="self-end text-neutral-500 hover:bg-primary-50 hover:text-primary-500"
+                @click="emit('bulk-archive')"
+            />
+
             <!-- Delete -->
             <MalioButtonIcon
                 icon="mdi:delete-outline"
@@ -113,9 +124,11 @@ const props = withDefaults(defineProps<{
     groups: TaskGroup[]
     selectedTasks?: Task[]
     projects?: Project[]
+    canArchive?: boolean
 }>(), {
     selectedTasks: () => [],
     projects: () => [],
+    canArchive: false,
 })
 
 const emit = defineEmits<{

frontend/components/task/TaskDocumentList.vue

@@ -68,6 +68,7 @@ function isImage(mimeType: string): boolean {
 }
 
 function getIconForMime(mimeType: string): string {
+    if (mimeType === 'text/markdown') return 'mdi:language-markdown'
     if (mimeType === 'application/pdf') return 'heroicons:document-text'
     if (mimeType.includes('spreadsheet') || mimeType.includes('excel')) return 'heroicons:table-cells'
     if (mimeType.includes('word') || mimeType.includes('document')) return 'heroicons:document'

frontend/components/task/TaskDocumentPreview.vue

@@ -58,6 +58,46 @@
                         class="h-[85vh] w-[80vw] rounded-lg bg-white"
                     />
 
+                    <!-- Text / Markdown preview -->
+                    <div
+                        v-else-if="isText"
+                        class="flex max-h-[85vh] w-[85vw] max-w-3xl flex-col overflow-hidden rounded-xl bg-white"
+                    >
+                        <div class="flex items-center justify-between gap-2 border-b border-neutral-200 px-4 py-3">
+                            <p class="truncate text-sm font-medium text-neutral-700">{{ document.originalName }}</p>
+                            <div class="flex shrink-0 items-center gap-2">
+                                <button
+                                    type="button"
+                                    class="inline-flex items-center gap-1.5 rounded-lg bg-neutral-100 px-3 py-1.5 text-sm font-medium text-neutral-700 transition-colors hover:bg-neutral-200"
+                                    @click="copyContent"
+                                >
+                                    <Icon
+                                        :name="copied ? 'heroicons:check' : 'mdi:content-copy'"
+                                        class="h-4 w-4"
+                                        :class="copied ? 'text-green-600' : ''"
+                                    />
+                                    {{ copied ? $t('taskDocuments.copied') : $t('taskDocuments.copy') }}
+                                </button>
+                                <a
+                                    :href="downloadUrl"
+                                    download
+                                    class="inline-flex items-center gap-1.5 rounded-lg bg-blue-600 px-3 py-1.5 text-sm font-semibold text-white transition-colors hover:bg-blue-700"
+                                >
+                                    {{ $t('taskDocuments.download') }}
+                                </a>
+                            </div>
+                        </div>
+                        <div class="overflow-auto p-4">
+                            <div v-if="loadingText" class="flex justify-center py-10">
+                                <Icon name="heroicons:arrow-path" class="h-6 w-6 animate-spin text-neutral-400" />
+                            </div>
+                            <pre
+                                v-else
+                                class="whitespace-pre-wrap break-words font-mono text-xs leading-relaxed text-neutral-800"
+                            >{{ textContent }}</pre>
+                        </div>
+                    </div>
+
                     <!-- Generic file -->
                     <div v-else class="flex flex-col items-center gap-4 rounded-xl bg-white p-10">
                         <Icon name="heroicons:document" class="h-16 w-16 text-neutral-400" />
@@ -73,7 +113,7 @@
                     </div>
 
                     <!-- File name footer -->
-                    <p class="mt-3 text-sm text-white/70">{{ document.originalName }}</p>
+                    <p v-if="!isText" class="mt-3 text-sm text-white/70">{{ document.originalName }}</p>
                 </div>
             </div>
         </Transition>
@@ -98,19 +138,56 @@ defineEmits<{
 }>()
 
 const overlayRef = ref<HTMLElement | null>(null)
+const textContent = ref('')
+const loadingText = ref(false)
+const copied = ref(false)
 
-const { getDownloadUrl } = useTaskDocumentService()
+const { getDownloadUrl, getContent } = useTaskDocumentService()
+const { t } = useI18n()
+
+const TEXT_MIME_TYPES = ['text/markdown', 'text/plain', 'text/csv', 'application/json', 'application/xml', 'text/xml']
+
+function isTextDocument(doc: TaskDocument | null): boolean {
+    if (!doc) return false
+    if (TEXT_MIME_TYPES.includes(doc.mimeType)) return true
+    return /\.(md|markdown|txt|csv|json|xml)$/i.test(doc.originalName)
+}
 
 const downloadUrl = computed(() => props.document ? getDownloadUrl(props.document.id) : '')
 const isImage = computed(() => props.document?.mimeType.startsWith('image/') ?? false)
 const isPdf = computed(() => props.document?.mimeType === 'application/pdf')
+const isText = computed(() => isTextDocument(props.document))
 
-// Focus overlay for keyboard events
-watch(() => props.document, (doc) => {
-    if (doc) {
-        nextTick(() => overlayRef.value?.focus())
+async function copyContent() {
+    try {
+        await navigator.clipboard.writeText(textContent.value)
+        copied.value = true
+        useToast().success(t('taskDocuments.copied'))
+        setTimeout(() => { copied.value = false }, 2000)
+    } catch {
+        // Clipboard unavailable
     }
-})
+}
+
+// Focus overlay for keyboard events, and load text content for text/markdown documents
+watch(() => props.document, async (doc) => {
+    textContent.value = ''
+    copied.value = false
+    if (!doc) return
+
+    nextTick(() => overlayRef.value?.focus())
+
+    if (isTextDocument(doc)) {
+        loadingText.value = true
+        try {
+            textContent.value = await getContent(doc.id)
+        } catch {
+            textContent.value = ''
+        } finally {
+            loadingText.value = false
+        }
+    }
+}, { immediate: true })
 </script>
 
 <style scoped>

frontend/components/user/UserDrawer.vue

@@ -11,6 +11,16 @@
                 :error="touched.username && !form.username.trim() ? 'Le nom est requis' : ''"
                 @blur="touched.username = true"
             />
+            <MalioInputText
+                v-model="form.firstName"
+                label="Prénom"
+                input-class="w-full"
+            />
+            <MalioInputText
+                v-model="form.lastName"
+                label="Nom"
+                input-class="w-full"
+            />
             <MalioInputPassword
                 v-model="form.password"
                 label="Mot de passe"
@@ -84,6 +94,8 @@ const isSubmitting = ref(false)
 
 const form = reactive({
     username: '',
+    firstName: '',
+    lastName: '',
     password: '',
     roles: [] as string[],
     isEmployee: false,
@@ -98,11 +110,15 @@ watch(() => props.modelValue, (open) => {
     if (open) {
         if (props.item) {
             form.username = props.item.username ?? ''
+            form.firstName = props.item.firstName ?? ''
+            form.lastName = props.item.lastName ?? ''
             form.password = ''
             form.roles = [...props.item.roles]
             form.isEmployee = props.item.isEmployee ?? false
         } else {
             form.username = ''
+            form.firstName = ''
+            form.lastName = ''
             form.password = ''
             form.roles = ['ROLE_USER']
             form.isEmployee = false
@@ -124,6 +140,8 @@ async function handleSubmit() {
     try {
         const payload: UserWrite = {
             username: form.username.trim(),
+            firstName: form.firstName.trim() || null,
+            lastName: form.lastName.trim() || null,
             roles: form.roles,
             isEmployee: form.isEmployee,
         }

frontend/composables/useAbsenceHelpers.ts

@@ -75,9 +75,11 @@ export function useAbsenceHelpers() {
     }
 
     function formatDays(days: number): string {
-        const rounded = Math.round(days * 2) / 2
-        const unit = rounded > 1 ? t('absences.daysPlural') : t('absences.daySingular')
-        return `${rounded} ${unit}`
+        // Affiche la valeur réelle avec décimales (ex. 8,75) : un solde de CP se
+        // gère en demi/quart de journée, arrondir masquerait des droits réels.
+        const value = new Intl.NumberFormat('fr-FR', { maximumFractionDigits: 2 }).format(days)
+        const unit = days >= 2 ? t('absences.daysPlural') : t('absences.daySingular')
+        return `${value} ${unit}`
     }
 
     return {

frontend/i18n/locales/fr.json

@@ -126,6 +126,8 @@
         "confirmDeleteTitle": "Supprimer le document",
         "confirmDeleteMessage": "Êtes-vous sûr de vouloir supprimer ce document ?",
         "download": "Télécharger",
+        "copy": "Copier",
+        "copied": "Contenu copié !",
         "maxSizeError": "Le fichier dépasse la taille maximale de 50 Mo."
     },
     "tasks": {

frontend/nuxt.config.ts

@@ -2,7 +2,7 @@ export default defineNuxtConfig({
     compatibilityDate: '2025-07-15',
     devtools: {enabled: false},
     ssr: false,
-    css: ['~/assets/css/dark.css'],
+    css: ['~/assets/css/app.css', '~/assets/css/dark.css'],
     app: {
         baseURL: process.env.NODE_ENV === 'production'
             ? (process.env.NUXT_PUBLIC_APP_BASE || '/')

frontend/pages/projects/[id]/index.vue

@@ -161,6 +161,7 @@
                 :priorities="priorities"
                 :efforts="efforts"
                 :groups="groups"
+                :can-archive="canArchiveSelection"
                 @toggle-all="toggleSelectAll(filteredTasks)"
                 @bulk-update="onBulkUpdate"
                 @bulk-archive="onBulkArchive"
@@ -297,6 +298,12 @@ const effortFilterOptions = computed(() =>
     efforts.value.map(e => ({ label: e.label, value: e.id }))
 )
 
+const canArchiveSelection = computed(() => {
+    if (selectedStatusId.value === null) return false
+    const status = statuses.value.find(s => s.id === selectedStatusId.value)
+    return status?.isFinal === true
+})
+
 const filteredTasks = computed(() => {
     let result = tasks.value.filter(t => !t.archived)
     if (selectedGroupId.value) {
@@ -323,6 +330,14 @@ const filteredTasks = computed(() => {
     return result
 })
 
+watch(filteredTasks, (list) => {
+    if (selectedTaskIds.size === 0) return
+    const visibleIds = new Set(list.map(t => t.id))
+    for (const id of selectedTaskIds) {
+        if (!visibleIds.has(id)) selectedTaskIds.delete(id)
+    }
+})
+
 function tasksByStatus(statusId: number): Task[] {
     return filteredTasks.value.filter(t => t.status?.id === statusId)
 }

frontend/services/dto/user-data.ts

@@ -4,6 +4,8 @@ export type UserData = {
     id: number
     '@id'?: string
     username: string
+    firstName?: string | null
+    lastName?: string | null
     roles: string[]
     avatarUrl?: string | null
     apiToken?: string | null
@@ -20,6 +22,8 @@ export type UserData = {
 
 export type UserWrite = {
     username: string
+    firstName?: string | null
+    lastName?: string | null
     plainPassword?: string
     roles: string[]
     // HR / absence management

frontend/services/task-documents.ts

@@ -41,5 +41,12 @@ export function useTaskDocumentService() {
         return `${baseURL}/task_documents/${id}/download`
     }
 
-    return { getByTask, upload, remove, getDownloadUrl }
+    async function getContent(id: number): Promise<string> {
+        return $fetch<string>(`${baseURL}/task_documents/${id}/download`, {
+            credentials: 'include',
+            responseType: 'text',
+        })
+    }
+
+    return { getByTask, upload, remove, getDownloadUrl, getContent }
 }

frontend/services/time-entries.ts

@@ -25,7 +25,7 @@ export function useTimeEntryService() {
         if (params.tag) {
             query['tags[]'] = `/api/task_tags/${params.tag}`
         }
-        const data = await api.get<HydraCollection<TimeEntry>>('/time_entries', query)
+        const data = await api.get<HydraCollection<TimeEntry>>('/time_entries/range', query)
         return extractHydraMembers(data)
     }
 

migrations/Version20260526120000.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Add optional first name / last name to users.
+ */
+final class Version20260526120000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Add user.first_name and user.last_name (nullable)';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE "user" ADD first_name VARCHAR(100) DEFAULT NULL');
+        $this->addSql('ALTER TABLE "user" ADD last_name VARCHAR(100) DEFAULT NULL');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE "user" DROP COLUMN IF EXISTS first_name');
+        $this->addSql('ALTER TABLE "user" DROP COLUMN IF EXISTS last_name');
+    }
+}

src/DataFixtures/AppFixtures.php

@@ -43,6 +43,8 @@ class AppFixtures extends Fixture
         // Users
         $admin = new User();
         $admin->setUsername('admin');
+        $admin->setFirstName('Alex');
+        $admin->setLastName('Martin');
         $admin->setRoles(['ROLE_ADMIN']);
         $admin->setPassword($this->passwordHasher->hashPassword($admin, 'admin'));
         $admin->setApiToken('dev-mcp-token-for-testing-only-do-not-use-in-production');
@@ -50,18 +52,24 @@ class AppFixtures extends Fixture
 
         $userAlice = new User();
         $userAlice->setUsername('alice');
+        $userAlice->setFirstName('Alice');
+        $userAlice->setLastName('Dupont');
         $userAlice->setRoles(['ROLE_USER']);
         $userAlice->setPassword($this->passwordHasher->hashPassword($userAlice, 'alice'));
         $manager->persist($userAlice);
 
         $userBob = new User();
         $userBob->setUsername('bob');
+        $userBob->setFirstName('Bob');
+        $userBob->setLastName('Leroy');
         $userBob->setRoles(['ROLE_USER']);
         $userBob->setPassword($this->passwordHasher->hashPassword($userBob, 'bob'));
         $manager->persist($userBob);
 
         $userCharlie = new User();
         $userCharlie->setUsername('charlie');
+        $userCharlie->setFirstName('Charlie');
+        $userCharlie->setLastName('Moreau');
         $userCharlie->setRoles(['ROLE_USER']);
         $userCharlie->setPassword($this->passwordHasher->hashPassword($userCharlie, 'charlie'));
         $manager->persist($userCharlie);

src/DependencyInjection/Compiler/McpSchemaGeneratorPass.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\DependencyInjection\Compiler;
+
+use App\Mcp\Schema\CoercingSchemaGenerator;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Wires the CoercingSchemaGenerator into the MCP server builder so that
+ * generated tool input schemas accept stringified scalar arguments.
+ */
+final class McpSchemaGeneratorPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->hasDefinition('mcp.server.builder')) {
+            return;
+        }
+
+        $container->getDefinition('mcp.server.builder')
+            ->addMethodCall('setSchemaGenerator', [new Reference(CoercingSchemaGenerator::class)])
+        ;
+    }
+}

src/Entity/TimeEntry.php

@@ -25,6 +25,13 @@ use Symfony\Component\Serializer\Attribute\Groups;
 #[ApiResource(
     operations: [
         new GetCollection(security: "is_granted('ROLE_USER')"),
+        new GetCollection(
+            name: 'time_entries_range',
+            uriTemplate: '/time_entries/range',
+            description: 'List time entries for a bounded date range without pagination (used by the time-tracking calendar)',
+            paginationEnabled: false,
+            security: "is_granted('ROLE_USER')",
+        ),
         new GetCollection(
             name: 'active_time_entry',
             uriTemplate: '/time_entries/active',

src/Entity/User.php

@@ -55,6 +55,14 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
     #[Groups(['me:read', 'task:read', 'user:list', 'user:write', 'time_entry:read', 'absence_request:read', 'absence_balance:read'])]
     private ?string $username = null;
 
+    #[ORM\Column(length: 100, nullable: true)]
+    #[Groups(['me:read', 'user:list', 'user:write'])]
+    private ?string $firstName = null;
+
+    #[ORM\Column(length: 100, nullable: true)]
+    #[Groups(['me:read', 'user:list', 'user:write'])]
+    private ?string $lastName = null;
+
     /** @var list<string> */
     #[ORM\Column]
     #[ApiProperty(security: "is_granted('ROLE_ADMIN') or object == user")]
@@ -147,6 +155,30 @@ class User implements UserInterface, PasswordAuthenticatedUserInterface
         return $this;
     }
 
+    public function getFirstName(): ?string
+    {
+        return $this->firstName;
+    }
+
+    public function setFirstName(?string $firstName): static
+    {
+        $this->firstName = $firstName;
+
+        return $this;
+    }
+
+    public function getLastName(): ?string
+    {
+        return $this->lastName;
+    }
+
+    public function setLastName(?string $lastName): static
+    {
+        $this->lastName = $lastName;
+
+        return $this;
+    }
+
     public function getUserIdentifier(): string
     {
         return (string) $this->username;

src/Kernel.php

@@ -4,10 +4,17 @@ declare(strict_types=1);
 
 namespace App;
 
+use App\DependencyInjection\Compiler\McpSchemaGeneratorPass;
 use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Kernel as BaseKernel;
 
 class Kernel extends BaseKernel
 {
     use MicroKernelTrait;
+
+    protected function build(ContainerBuilder $container): void
+    {
+        $container->addCompilerPass(new McpSchemaGeneratorPass());
+    }
 }

src/Mcp/EventListener/CoerceJsonEncodedArgumentsListener.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Mcp\EventListener;
+
+use App\Mcp\Schema\CoercingSchemaGenerator;
+use Mcp\Capability\RegistryInterface;
+use Mcp\Event\RequestEvent;
+use Mcp\Schema\Request\CallToolRequest;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
+use Throwable;
+
+use function is_array;
+use function is_string;
+
+/**
+ * Decodes JSON-encoded structured arguments before tool calls are validated.
+ *
+ * Some MCP clients/proxies serialize array and object arguments as JSON strings
+ * (e.g. `tagIds` arrives as the string `"[3]"` instead of the array `[3]`). The
+ * SDK validates arguments against the JSON Schema BEFORE casting, so an `array`
+ * schema rejects the string with a 422, and ReferenceHandler::castToArray does
+ * not decode JSON strings either.
+ *
+ * This listener runs on the SDK RequestEvent (dispatched before any handler) and,
+ * driven by the tool's input schema, decodes string arguments whose target type
+ * is `array` or `object`. Scalar stringification is handled separately by
+ * {@see CoercingSchemaGenerator}.
+ */
+#[AsEventListener(event: RequestEvent::class)]
+final class CoerceJsonEncodedArgumentsListener
+{
+    public function __construct(
+        #[Autowire(service: 'mcp.registry')]
+        private readonly RegistryInterface $registry,
+    ) {}
+
+    public function __invoke(RequestEvent $event): void
+    {
+        $request = $event->getRequest();
+        if (!$request instanceof CallToolRequest) {
+            return;
+        }
+
+        $arguments = $request->arguments;
+        if ([] === $arguments) {
+            return;
+        }
+
+        $properties = $this->toolProperties($request->name);
+        if (null === $properties) {
+            return;
+        }
+
+        $changed = false;
+        foreach ($arguments as $name => $value) {
+            if (!is_string($value) || !is_array($properties[$name] ?? null)) {
+                continue;
+            }
+
+            $types = (array) ($properties[$name]['type'] ?? []);
+            if ([] === array_intersect(['array', 'object'], $types)) {
+                continue;
+            }
+
+            $decoded = json_decode($value, true);
+            if (is_array($decoded)) {
+                $arguments[$name] = $decoded;
+                $changed          = true;
+            }
+        }
+
+        if ($changed) {
+            $event->setRequest(
+                new CallToolRequest($request->name, $arguments)
+                    ->withId($request->getId())
+                    ->withMeta($request->getMeta()),
+            );
+        }
+    }
+
+    /**
+     * @return null|array<string, mixed>
+     */
+    private function toolProperties(string $toolName): ?array
+    {
+        try {
+            $schema = $this->registry->getTool($toolName)->tool->inputSchema;
+        } catch (Throwable) {
+            return null;
+        }
+
+        $properties = $schema['properties'] ?? null;
+
+        return is_array($properties) ? $properties : null;
+    }
+}

src/Mcp/Schema/CoercingSchemaGenerator.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Mcp\Schema;
+
+use Mcp\Capability\Discovery\DocBlockParser;
+use Mcp\Capability\Discovery\SchemaGenerator;
+use Mcp\Capability\Discovery\SchemaGeneratorInterface;
+use Reflector;
+
+use function count;
+use function in_array;
+use function is_array;
+
+/**
+ * Wraps the SDK SchemaGenerator and relaxes scalar parameter schemas so that
+ * numeric/boolean parameters also accept their string representation.
+ *
+ * Rationale: some MCP clients serialize every JSON-RPC argument as a string
+ * (e.g. `"22"` instead of `22`). The SDK validates arguments against the
+ * generated JSON Schema BEFORE casting them (see CallToolHandler), so a strict
+ * `integer` schema rejects `"22"` with a 422 even though the SDK's
+ * ReferenceHandler::castArgumentType would happily coerce it afterwards.
+ *
+ * By advertising `["integer", "string"]` (resp. number/boolean) we let opis
+ * accept the stringified value; the reflected PHP type hint (`int`, `bool`, ...)
+ * still drives the actual coercion in ReferenceHandler. Non-numeric strings are
+ * rejected later with a clear "cannot cast" error.
+ */
+final class CoercingSchemaGenerator implements SchemaGeneratorInterface
+{
+    public function __construct(
+        private readonly SchemaGeneratorInterface $inner = new SchemaGenerator(new DocBlockParser()),
+    ) {}
+
+    public function generate(Reflector $reflection): array
+    {
+        $schema = $this->inner->generate($reflection);
+
+        if (isset($schema['properties']) && is_array($schema['properties'])) {
+            foreach ($schema['properties'] as $name => $property) {
+                if (is_array($property)) {
+                    $schema['properties'][$name] = $this->relaxNode($property);
+                }
+            }
+        }
+
+        return $schema;
+    }
+
+    public function generateOutputSchema(Reflector $reflection): ?array
+    {
+        return $this->inner->generateOutputSchema($reflection);
+    }
+
+    /**
+     * @param array<string, mixed> $node
+     *
+     * @return array<string, mixed>
+     */
+    private function relaxNode(array $node): array
+    {
+        if (isset($node['type'])) {
+            $node['type'] = $this->relaxType($node['type']);
+        }
+
+        // Relax array element types too (stringified IDs inside tagIds, etc.).
+        if (isset($node['items']) && is_array($node['items'])) {
+            $node['items'] = $this->relaxNode($node['items']);
+        }
+
+        return $node;
+    }
+
+    /**
+     * Adds "string" to a type definition that allows integer/number/boolean.
+     *
+     * @param string|string[] $type
+     *
+     * @return string|string[]
+     */
+    private function relaxType(array|string $type): array|string
+    {
+        $types = (array) $type;
+
+        $isNumericOrBool = in_array('integer', $types, true)
+            || in_array('number', $types, true)
+            || in_array('boolean', $types, true);
+
+        if ($isNumericOrBool && !in_array('string', $types, true)) {
+            $types[] = 'string';
+        }
+
+        return 1 === count($types) ? $types[0] : array_values($types);
+    }
+}

src/Mcp/Tool/Task/AddTaskDocumentTool.php

@@ -0,0 +1,110 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Mcp\Tool\Task;
+
+use App\Entity\TaskDocument;
+use App\Repository\TaskRepository;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use InvalidArgumentException;
+use Mcp\Capability\Attribute\McpTool;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\Security\Core\Exception\AccessDeniedException;
+use Symfony\Component\Uid\Uuid;
+
+use function sprintf;
+use function strlen;
+
+#[McpTool(name: 'add-task-document', description: 'Attach a text document (Markdown by default) to a task by passing its raw content. Optimized for Markdown reports/notes: the content is written verbatim as a UTF-8 file, no base64 needed. The MIME type is inferred from the fileName extension (.md, .txt, .csv, .json, .xml), defaulting to text/markdown.')]
+class AddTaskDocumentTool
+{
+    private const MAX_CONTENT_SIZE = 5 * 1024 * 1024; // 5 MB of text
+
+    private const EXTENSION_TO_MIME = [
+        'md'       => 'text/markdown',
+        'markdown' => 'text/markdown',
+        'txt'      => 'text/plain',
+        'csv'      => 'text/csv',
+        'json'     => 'application/json',
+        'xml'      => 'text/xml',
+    ];
+
+    public function __construct(
+        private readonly EntityManagerInterface $entityManager,
+        private readonly TaskRepository $taskRepository,
+        private readonly Security $security,
+        private readonly string $uploadDir,
+    ) {}
+
+    /**
+     * @param int    $taskId   ID of the task to attach the document to
+     * @param string $content  Raw text content of the document (e.g. Markdown)
+     * @param string $fileName Display name of the document, including extension (defaults to "document.md")
+     */
+    public function __invoke(
+        int $taskId,
+        string $content,
+        string $fileName = 'document.md',
+    ): string {
+        if (!$this->security->isGranted('ROLE_USER')) {
+            throw new AccessDeniedException('Access denied: ROLE_USER required.');
+        }
+
+        $task = $this->taskRepository->find($taskId);
+        if (null === $task) {
+            throw new InvalidArgumentException(sprintf('Task with ID %d not found.', $taskId));
+        }
+
+        if ('' === $content) {
+            throw new InvalidArgumentException('Document content cannot be empty.');
+        }
+
+        $size = strlen($content);
+        if ($size > self::MAX_CONTENT_SIZE) {
+            throw new InvalidArgumentException('Content size exceeds 5 MB limit.');
+        }
+
+        $originalName = '' !== trim($fileName) ? trim($fileName) : 'document.md';
+
+        $extension = strtolower(pathinfo($originalName, PATHINFO_EXTENSION));
+        $mimeType  = self::EXTENSION_TO_MIME[$extension] ?? 'text/markdown';
+        if ('' === $extension) {
+            $originalName .= '.md';
+            $extension = 'md';
+        }
+
+        $storedName = Uuid::v4()->toRfc4122().'.'.$extension;
+
+        if (!is_dir($this->uploadDir) && !mkdir($this->uploadDir, 0o775, true) && !is_dir($this->uploadDir)) {
+            throw new InvalidArgumentException(sprintf('Upload directory "%s" could not be created.', $this->uploadDir));
+        }
+
+        if (false === file_put_contents($this->uploadDir.'/'.$storedName, $content)) {
+            throw new InvalidArgumentException('Failed to write document to disk.');
+        }
+
+        $document = new TaskDocument();
+        $document->setTask($task);
+        $document->setOriginalName($originalName);
+        $document->setFileName($storedName);
+        $document->setMimeType($mimeType);
+        $document->setSize($size);
+        $document->setCreatedAt(new DateTimeImmutable());
+        $document->setUploadedBy($this->security->getUser());
+
+        $this->entityManager->persist($document);
+        $this->entityManager->flush();
+
+        return json_encode([
+            'id'           => $document->getId(),
+            'taskId'       => $task->getId(),
+            'originalName' => $document->getOriginalName(),
+            'mimeType'     => $document->getMimeType(),
+            'size'         => $document->getSize(),
+            'createdAt'    => $document->getCreatedAt()?->format('c'),
+            'uploadedBy'   => $document->getUploadedBy()?->getUsername(),
+        ]);
+    }
+}

src/Mcp/Tool/Task/CreateTaskTool.php

@@ -41,6 +41,10 @@ class CreateTaskTool
         private readonly CalDavService $calDavService,
     ) {}
 
+    /**
+     * @param int[] $tagIds          IDs of the tags to attach
+     * @param int[] $collaboratorIds IDs of the collaborators to attach
+     */
     public function __invoke(
         int $projectId,
         string $title,

src/Mcp/Tool/Task/ListTasksTool.php

@@ -18,6 +18,9 @@ class ListTasksTool
         private readonly Security $security,
     ) {}
 
+    /**
+     * @param int[] $tagIds IDs of the tags to filter by
+     */
     public function __invoke(
         ?int $projectId = null,
         ?int $statusId = null,

src/Mcp/Tool/Task/UpdateTaskTool.php

@@ -38,6 +38,10 @@ class UpdateTaskTool
         private readonly CalDavService $calDavService,
     ) {}
 
+    /**
+     * @param int[] $tagIds          IDs of the tags to attach
+     * @param int[] $collaboratorIds IDs of the collaborators to attach
+     */
     public function __invoke(
         int $id,
         ?string $title = null,

src/Mcp/Tool/TimeEntry/CreateTimeEntryTool.php

@@ -33,6 +33,9 @@ class CreateTimeEntryTool
         private readonly Security $security,
     ) {}
 
+    /**
+     * @param int[] $tagIds IDs of the tags to attach
+     */
     public function __invoke(
         int $userId,
         string $startedAt,

src/Mcp/Tool/TimeEntry/UpdateTimeEntryTool.php

@@ -30,6 +30,9 @@ class UpdateTimeEntryTool
         private readonly Security $security,
     ) {}
 
+    /**
+     * @param int[] $tagIds IDs of the tags to attach
+     */
     public function __invoke(
         int $id,
         ?string $title = null,

tests/Unit/Mcp/CoerceJsonEncodedArgumentsListenerTest.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Mcp;
+
+use App\Mcp\EventListener\CoerceJsonEncodedArgumentsListener;
+use Mcp\Capability\Registry\ToolReference;
+use Mcp\Capability\RegistryInterface;
+use Mcp\Event\RequestEvent;
+use Mcp\Schema\Request\CallToolRequest;
+use Mcp\Schema\Tool;
+use Mcp\Server\Session\SessionInterface;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+class CoerceJsonEncodedArgumentsListenerTest extends TestCase
+{
+    private const SCHEMA = [
+        'type'       => 'object',
+        'properties' => [
+            'id'              => ['type' => ['integer', 'string']],
+            'title'           => ['type' => 'string'],
+            'tagIds'          => ['type' => ['array', 'null'], 'items' => ['type' => ['integer', 'string']]],
+            'collaboratorIds' => ['type' => ['array', 'null'], 'items' => ['type' => ['integer', 'string']]],
+        ],
+    ];
+
+    public function testDecodesJsonStringArrayForArrayTypedParam(): void
+    {
+        $result = $this->handle(['tagIds' => '[3]', 'collaboratorIds' => '[5,6]']);
+
+        self::assertSame([3], $result->arguments['tagIds']);
+        self::assertSame([5, 6], $result->arguments['collaboratorIds']);
+    }
+
+    public function testLeavesRealArrayUntouched(): void
+    {
+        $result = $this->handle(['tagIds' => [3]]);
+
+        self::assertSame([3], $result->arguments['tagIds']);
+    }
+
+    public function testDoesNotTouchStringTypedParamEvenIfItLooksLikeJson(): void
+    {
+        $result = $this->handle(['title' => '[1,2]']);
+
+        // title is schema-typed string -> must stay the literal string.
+        self::assertSame('[1,2]', $result->arguments['title']);
+    }
+
+    public function testLeavesScalarTypedParamUntouched(): void
+    {
+        // id is integer/string typed -> not an array/object, handled by the schema
+        // relaxation + SDK cast, not by this listener.
+        $result = $this->handle(['id' => '463']);
+
+        self::assertSame('463', $result->arguments['id']);
+    }
+
+    public function testPreservesRequestId(): void
+    {
+        $result = $this->handle(['tagIds' => '[3]']);
+
+        self::assertSame(1, $result->getId());
+    }
+
+    /**
+     * @param array<string, mixed> $arguments
+     */
+    private function handle(array $arguments): CallToolRequest
+    {
+        $tool      = new Tool('update-task', self::SCHEMA, null, null);
+        $reference = new ToolReference($tool, static fn () => null);
+
+        $registry = $this->createMock(RegistryInterface::class);
+        $registry->method('getTool')->willReturn($reference);
+
+        $request = new CallToolRequest('update-task', $arguments)->withId(1);
+        $event   = new RequestEvent($request, $this->createMock(SessionInterface::class));
+
+        (new CoerceJsonEncodedArgumentsListener($registry))($event);
+
+        $result = $event->getRequest();
+        self::assertInstanceOf(CallToolRequest::class, $result);
+
+        return $result;
+    }
+}

tests/Unit/Mcp/CoercingSchemaGeneratorTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Mcp;
+
+use App\Mcp\Schema\CoercingSchemaGenerator;
+use App\Mcp\Tool\Task\CreateTaskTool;
+use App\Mcp\Tool\Task\ListTasksTool;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+
+/**
+ * @internal
+ */
+class CoercingSchemaGeneratorTest extends TestCase
+{
+    private CoercingSchemaGenerator $generator;
+
+    protected function setUp(): void
+    {
+        $this->generator = new CoercingSchemaGenerator();
+    }
+
+    public function testNullableIntegerScalarAlsoAcceptsString(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(ListTasksTool::class, '__invoke'));
+
+        // ?int $projectId -> ["null","integer"] relaxed with "string".
+        self::assertSame(['null', 'integer', 'string'], $schema['properties']['projectId']['type']);
+    }
+
+    public function testRequiredIntegerScalarAlsoAcceptsString(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(ListTasksTool::class, '__invoke'));
+
+        // int $limit = 100 -> "integer" relaxed to ["integer","string"].
+        self::assertSame(['integer', 'string'], $schema['properties']['limit']['type']);
+    }
+
+    public function testBooleanScalarAlsoAcceptsString(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(CreateTaskTool::class, '__invoke'));
+
+        // ?bool $syncToCalendar -> ["boolean","null"] relaxed with "string".
+        $type = $schema['properties']['syncToCalendar']['type'];
+        self::assertContains('boolean', $type);
+        self::assertContains('string', $type);
+        self::assertContains('null', $type);
+    }
+
+    public function testArrayItemTypeAlsoAcceptsString(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(CreateTaskTool::class, '__invoke'));
+
+        // int[] $tagIds -> items {type: integer} relaxed to {type: [integer, string]}.
+        self::assertSame(['integer', 'string'], $schema['properties']['tagIds']['items']['type']);
+    }
+
+    public function testStringScalarIsLeftUntouched(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(CreateTaskTool::class, '__invoke'));
+
+        // string $title stays a plain string (no spurious relaxation).
+        self::assertSame('string', $schema['properties']['title']['type']);
+    }
+
+    public function testArrayContainerTypeIsNotRelaxed(): void
+    {
+        $schema = $this->generator->generate(new ReflectionMethod(CreateTaskTool::class, '__invoke'));
+
+        // The array container itself must not gain "string".
+        self::assertSame(['array', 'null'], $schema['properties']['tagIds']['type']);
+    }
+}