modifiche

app/Console/Commands/ImportaRedmine.php

                             {--user-fallback= : ID utente locale se non c\'è match}
                             {--tariffa= : €/ora per calcolare il costo dai tempi}
                             {--contratto= : ID del contratto servizio da assegnare alle segnalazioni}
-                            {--limit= : Importa al massimo N issue (per progetto)}';
+                            {--limit= : Importa al massimo N issue (per progetto)}
+                            {--sync-cc : Aggiorna solo CC/CCN dalle ticket Helpdesk, senza reimportare le issue}';
 
     protected $description = 'Importa issue, tempi, costi e allegati da Redmine 6.x. Senza progetto importa tutti i progetti e crea le aziende mancanti.';
 
             return $this->listProjects($client);
         }
 
+        if ($this->option('sync-cc')) {
+            return $this->syncCc($client);
+        }
+
         $projectArg = $this->argument('project');
         $aziendaArg = $this->argument('azienda');
 
         }
     }
 
+    protected function syncCc(RedmineClient $client): int
+    {
+        $limit = $this->option('limit');
+        $this->info('Sincronizzo CC/CCN dalle ticket Helpdesk Redmine ('.$client->baseUrl().').');
+        if ($this->option('dry-run')) {
+            $this->warn('Modalità dry-run: nessuna scrittura sul database.');
+        }
+
+        try {
+            $stats = RedmineImportService::syncHelpdeskCc(
+                $client,
+                (bool) $this->option('dry-run'),
+                $limit !== null && $limit !== '' ? (int) $limit : null,
+                function (int $current, int $total) {
+                    if ($current === 1) {
+                        $this->output->progressStart($total);
+                    }
+                    $this->output->progressAdvance();
+                    if ($current === $total) {
+                        $this->output->progressFinish();
+                    }
+                },
+            );
+        } catch (Throwable $e) {
+            $this->error($e->getMessage());
+
+            return self::FAILURE;
+        }
+
+        $this->newLine();
+        $this->table(
+            ['Voce', 'Valore'],
+            [
+                ['Segnalazioni Redmine', $stats['tickets']],
+                ['Segnalazioni aggiornate', $stats['updated']],
+                ['Senza ticket Helpdesk / già allineate', $stats['skipped']],
+                ['Senza CC da importare', $stats['empty']],
+            ],
+        );
+
+        return self::SUCCESS;
+    }
+
     /**
      * @param  array<string, mixed>  $stats
      */

app/Http/Controllers/SegnalazioneController.php

       'slots.*.ora_fine' => 'nullable|date_format:H:i',
       'allegato' => 'nullable|array',
       'allegato.*' => 'file|max:10240', // max 10MB per file
+      'cc' => 'nullable|string',
+      'bcc' => 'nullable|string',
     ]);
 
     if ($request->filled('ordine_lavoro_id') && $request->filled('contratto_servizio_id')) {
     $segnalazione->tempo_stimato = $request->filled('tempo_stimato')
       ? round((float) $request->input('tempo_stimato'), 2)
       : null;
+    $this->applyCcBccFromRequest($segnalazione, $request);
     $segnalazione->save();
 
     // Sync slot prenotazione (solo in stato pianificata; altrimenti svuota)
       'descrizione' => 'required|string',
       'allegato' => 'nullable|array',
       'allegato.*' => 'file|max:10240', // max 10MB per file
+      'cc' => 'nullable|string',
+      'bcc' => 'nullable|string',
     ]);
 
     $validator->after(function ($validator) use ($request) {
         $segnalazione->origine = 'manuale';
       }
       $segnalazione->notificaApertaDa = $request->boolean('notifica_aperta_da');
+      $this->applyCcBccFromRequest($segnalazione, $request);
       $categoriaSicurezzaValue = $request->input('categoria_sicurezza');
       if ($categoriaSicurezzaValue !== null && $categoriaSicurezzaValue !== '') {
         $tipoConfig = ConfiguraSegnalazione::where('gruppo', 'Tipo')
         return $query->get();
     }
 
+    protected function applyCcBccFromRequest(Segnalazione $segnalazione, Request $request): void
+    {
+        $exclude = [];
+        $userId = $request->filled('user_id') ? (int) $request->user_id : (int) $segnalazione->user_id;
+        if ($userId > 0) {
+            $email = User::query()->where('id', $userId)->value('email');
+            if ($email) {
+                $exclude[] = (string) $email;
+            }
+        }
+        $segnalazione->applyDestinatariFromRequest($request->input('cc'), $request->input('bcc'), $exclude);
+    }
+
     public function admin_delete(Request $request, $id)
     {
       $segnalazione = Segnalazione::find($id);

app/Models/Segnalazione.php

   /** Flag runtime: non notificare il cliente (Aperta da) su questo salvataggio. */
   public bool $skipNotificaCliente = false;
 
+  public function getCasts()
+  {
+    return array_merge(parent::getCasts(), [
+      'cc' => 'array',
+      'bcc' => 'array',
+    ]);
+  }
+
+  public function getFillable()
+  {
+    return array_merge(parent::getFillable(), [
+      'cc',
+      'bcc',
+    ]);
+  }
+
   // public function getCasts()
   // {
   //   return array_merge(parent::getCasts(), [
     }
 
     /**
-     * Notifica pubblica all'utente "Aperta da", come per un'annotazione standard.
+     * Normalizza una lista di indirizzi (JSON Tagify, CSV, array).
+     *
+     * @return list<string>
+     */
+    public static function parseEmailList(mixed $value): array
+    {
+        if ($value === null || $value === '') {
+            return [];
+        }
+        if (is_array($value)) {
+            $items = $value;
+        } else {
+            $raw = trim((string) $value);
+            $decoded = json_decode($raw, true);
+            $items = is_array($decoded) ? $decoded : (preg_split('/[;,]+/', $raw) ?: []);
+        }
+
+        $emails = [];
+        foreach ($items as $item) {
+            if (is_array($item)) {
+                $item = $item['value'] ?? $item['email'] ?? $item['address'] ?? $item['mail'] ?? null;
+            }
+            $email = strtolower(trim((string) $item));
+            if ($email !== '' && filter_var($email, FILTER_VALIDATE_EMAIL)) {
+                $emails[] = $email;
+            }
+        }
+
+        return array_values(array_unique($emails));
+    }
+
+    /**
+     * @return list<string>
+     */
+    public static function internalMailboxEmails(): array
+    {
+        $emails = [
+            (string) config('mail.from.address'),
+            (string) config('mail.reply_to.address'),
+        ];
+        $from = strtolower(trim((string) config('mail.from.address')));
+        if ($from !== '' && str_contains($from, '@')) {
+            $domain = substr($from, strrpos($from, '@'));
+            foreach (['assistenza', 'assistenzatest', 'noreply', 'no-reply'] as $local) {
+                $emails[] = $local.$domain;
+            }
+        }
+        try {
+            $emails = array_merge($emails, CasellaImap::query()->pluck('username')->all());
+        } catch (\Throwable) {
+            // tabella assente in alcuni ambienti
+        }
+
+        return array_values(array_unique(array_filter(array_map(
+            static fn ($e) => strtolower(trim((string) $e)),
+            $emails
+        ), static fn ($e) => $e !== '' && filter_var($e, FILTER_VALIDATE_EMAIL))));
+    }
+
+    /**
+     * @param  list<string>  $exclude
+     * @return list<string>
+     */
+    public function emailDestinatari(string $campo, array $exclude = []): array
+    {
+        $emails = self::parseEmailList($this->{$campo} ?? []);
+        $exclude = array_map('strtolower', array_filter($exclude));
+        $internal = self::internalMailboxEmails();
+
+        return array_values(array_filter(
+            $emails,
+            static fn (string $email) => ! in_array($email, $exclude, true) && ! in_array($email, $internal, true)
+        ));
+    }
+
+    /**
+     * @param  list<string>  $exclude
+     */
+    public function applyEmailDestinatari(\Illuminate\Notifications\Messages\MailMessage $mail, array $exclude = []): \Illuminate\Notifications\Messages\MailMessage
+    {
+        $cc = $this->emailDestinatari('cc', $exclude);
+        $bcc = $this->emailDestinatari('bcc', array_merge($exclude, $cc));
+        if ($cc !== []) {
+            $mail->cc($cc);
+        }
+        if ($bcc !== []) {
+            $mail->bcc($bcc);
+        }
+
+        return $mail;
+    }
+
+    /**
+     * Unisce indirizzi in CC (es. da mail in ingresso), senza toccare il mittente né le caselle interne.
+     *
+     * @param  list<string>  $emails
+     */
+    public function mergeCcEmails(array $emails, array $exclude = []): void
+    {
+        $exclude = array_map('strtolower', array_merge($exclude, self::internalMailboxEmails()));
+        $current = self::parseEmailList($this->cc);
+        foreach (self::parseEmailList($emails) as $email) {
+            if (! in_array($email, $exclude, true) && ! in_array($email, $current, true)) {
+                $current[] = $email;
+            }
+        }
+        $this->cc = $current !== [] ? $current : null;
+    }
+
+    /**
+     * Imposta CC (e BCC se presente) da un ticket Helpdesk Redmine.
+     *
+     * @param  array<string, mixed>|null  $ticket
+     */
+    public function applyHelpdeskAddresses(?array $ticket): void
+    {
+        if (! is_array($ticket)) {
+            return;
+        }
+
+        $from = strtolower(trim((string) ($ticket['from_address'] ?? '')));
+        $this->cc = null;
+        $this->mergeCcEmails(
+            array_merge(
+                self::parseEmailList($ticket['cc_address'] ?? ''),
+                self::parseEmailList($ticket['to_address'] ?? ''),
+            ),
+            array_filter([$from])
+        );
+
+        $bcc = self::parseEmailList($ticket['bcc_address'] ?? '');
+        if ($bcc === []) {
+            return;
+        }
+        $exclude = array_merge(
+            array_filter([$from]),
+            self::parseEmailList($this->cc),
+            self::internalMailboxEmails()
+        );
+        $bcc = array_values(array_filter(
+            $bcc,
+            static fn (string $email) => ! in_array($email, $exclude, true)
+        ));
+        $this->bcc = $bcc !== [] ? $bcc : null;
+    }
+
+    /**
+     * Imposta CC/CCN dal form (Tagify JSON, CSV o array).
+     */
+    public function applyDestinatariFromRequest(mixed $cc, mixed $bcc, array $exclude = []): void
+    {
+        $exclude = array_map('strtolower', array_filter($exclude));
+        $internal = self::internalMailboxEmails();
+        $ccList = array_values(array_filter(
+            self::parseEmailList($cc),
+            static fn (string $email) => ! in_array($email, $exclude, true) && ! in_array($email, $internal, true)
+        ));
+        $bccList = array_values(array_filter(
+            self::parseEmailList($bcc),
+            static fn (string $email) => ! in_array($email, $exclude, true)
+                && ! in_array($email, $ccList, true)
+                && ! in_array($email, $internal, true)
+        ));
+        $this->cc = $ccList !== [] ? $ccList : null;
+        $this->bcc = $bccList !== [] ? $bccList : null;
+    }
+
+    /**
+     * Notifica pubblica all'utente "Aperta da" (To) e agli indirizzi in CC/BCC.
      */
     public function notifyApertaDaAnnotazionePubblica(Annotazione $annotazione): void
     {

app/Notifications/AnnotazionePubblicaApertaDa.php

             ? $this->annotazione->user->full_name
             : trim((string) ($this->annotazione->riferimento ?: 'Operatore'));
 
-        return (new MailMessage)
+        $mail = (new MailMessage)
             ->subject($this->segnalazione->mailSubject(true))
             ->markdown('mail.annotazione-pubblica-aperta-da', [
                 'segnalazione' => $this->segnalazione,
                 'prioritaLabel' => $prioritaLabel,
                 'autoreLabel' => $autoreLabel,
             ]);
+
+        return $this->segnalazione->applyEmailDestinatari($mail, [
+            strtolower((string) ($notifiable->email ?? '')),
+        ]);
     }
 
     /**

app/Notifications/NuovaSegnalazioneUser.php

             report($e);
         }
 
+        if ($this->isApertaDa) {
+            return $this->segnalazione->applyEmailDestinatari($mail, [
+                strtolower((string) ($notifiable->email ?? '')),
+            ]);
+        }
+
         return $mail;
     }
 

app/Notifications/RispostaAutoSegnalazioneEmail.php

         $body = Config::testoRispostaAutoEmail($this->segnalazione);
         $paragraphs = preg_split("/\R{2,}/", trim($body)) ?: [];
 
-        return (new MailMessage)
+        $mail = (new MailMessage)
             ->subject($this->segnalazione->mailSubject(true))
             ->markdown('mail.risposta-auto-segnalazione-email', [
                 'segnalazione' => $this->segnalazione,
                     $paragraphs
                 ), static fn ($p) => $p !== '')),
             ]);
+
+        $to = '';
+        if (isset($notifiable->routes['mail'])) {
+            $route = $notifiable->routes['mail'];
+            if (is_array($route)) {
+                $firstKey = array_key_first($route);
+                $to = is_string($firstKey) && str_contains($firstKey, '@')
+                    ? $firstKey
+                    : (string) reset($route);
+            } else {
+                $to = (string) $route;
+            }
+        } else {
+            $to = (string) ($notifiable->email ?? '');
+        }
+
+        return $this->segnalazione->applyEmailDestinatari($mail, [strtolower($to)]);
     }
 
     /**

app/Services/Redmine/RedmineClient.php

         return is_array($data['helpdesk_ticket'] ?? null) ? $data['helpdesk_ticket'] : null;
     }
 
+    /**
+     * Elenco ticket Helpdesk (plugin RedmineUP). L'id coincide con l'issue.
+     *
+     * @return list<array<string, mixed>>
+     */
+    public function helpdeskTickets(?int $limit = null): array
+    {
+        $all = [];
+        $offset = 0;
+        $pageSize = 25;
+        $total = null;
+
+        try {
+            do {
+                try {
+                    $data = $this->get('helpdesk_tickets.json', [
+                        'offset' => $offset,
+                        'limit' => $pageSize,
+                    ]);
+                } catch (RuntimeException $e) {
+                    if ($e->getCode() !== 500) {
+                        throw $e;
+                    }
+                    if ($pageSize > 1) {
+                        $pageSize = 1;
+                        continue;
+                    }
+                    $offset++;
+                    if ($total !== null && $offset >= $total) {
+                        break;
+                    }
+                    continue;
+                }
+                $chunk = $data['helpdesk_tickets'] ?? [];
+                if (! is_array($chunk) || $chunk === []) {
+                    break;
+                }
+                foreach ($chunk as $item) {
+                    if (is_array($item)) {
+                        $all[] = $item;
+                    }
+                    if ($limit !== null && count($all) >= $limit) {
+                        return $all;
+                    }
+                }
+                $total = (int) ($data['total_count'] ?? ($offset + count($chunk)));
+                $offset += count($chunk);
+                if ($pageSize === 1 && count($chunk) === 1) {
+                    $pageSize = 25;
+                }
+            } while ($total === null || $offset < $total);
+        } catch (RuntimeException $e) {
+            if (in_array($e->getCode(), [404], true) && $all === []) {
+                return [];
+            }
+
+            throw $e;
+        }
+
+        return $all;
+    }
+
     /**
      * @return array<string, mixed>|null
      */

app/Services/Redmine/RedmineImportService.php

             'contact_id' => $this->lastContactMeta['id'] ?? null,
             'helpdesk_from' => $this->lastContactMeta['email'] ?? null,
         ]);
+        $helpdeskTicket = $issueId > 0 ? $this->cachedHelpdeskTicket($issueId) : null;
+        if (is_array($helpdeskTicket)) {
+            $segnalazione->applyHelpdeskAddresses($helpdeskTicket);
+            $meta['redmine']['helpdesk_from'] = $helpdeskTicket['from_address'] ?? $meta['redmine']['helpdesk_from'];
+            $meta['redmine']['helpdesk_to'] = $helpdeskTicket['to_address'] ?? null;
+            $meta['redmine']['helpdesk_cc'] = $helpdeskTicket['cc_address'] ?? null;
+        }
         $segnalazione->meta = $meta;
         Segnalazione::withoutAuditing(function () use ($segnalazione) {
             $segnalazione->save();
         return is_array($cached) ? $cached : null;
     }
 
+    /**
+     * Allinea CC/CCN delle segnalazioni già importate dai ticket Helpdesk, senza reimportare le issue.
+     *
+     * @return array{tickets:int, updated:int, skipped:int, empty:int}
+     */
+    public static function syncHelpdeskCc(RedmineClient $client, bool $dryRun = false, ?int $limit = null, ?callable $onProgress = null): array
+    {
+        $query = Segnalazione::query()->where('origine', 'redmine')->orderBy('id');
+        if ($limit !== null) {
+            $query->limit(max(0, $limit));
+        }
+        $segnalazioni = $query->get();
+        $stats = [
+            'tickets' => $segnalazioni->count(),
+            'updated' => 0,
+            'skipped' => 0,
+            'empty' => 0,
+        ];
+        $total = $segnalazioni->count();
+        $current = 0;
+
+        foreach ($segnalazioni as $segnalazione) {
+            $current++;
+            $issueId = (int) data_get($segnalazione->meta, 'redmine.issue_id', $segnalazione->id);
+            if ($onProgress) {
+                $onProgress($current, $total, $issueId);
+            }
+            if ($issueId <= 0) {
+                $stats['skipped']++;
+                continue;
+            }
+
+            $ticket = $client->helpdeskTicket($issueId);
+            if (! is_array($ticket)) {
+                $stats['skipped']++;
+                continue;
+            }
+
+            $beforeCc = self::normalizeEmailList($segnalazione->cc);
+            $segnalazione->applyHelpdeskAddresses($ticket);
+            $afterCc = self::normalizeEmailList($segnalazione->cc);
+
+            $meta = is_array($segnalazione->meta) ? $segnalazione->meta : [];
+            $meta['redmine'] = array_merge($meta['redmine'] ?? [], [
+                'helpdesk_from' => $ticket['from_address'] ?? data_get($meta, 'redmine.helpdesk_from'),
+                'helpdesk_to' => $ticket['to_address'] ?? null,
+                'helpdesk_cc' => $ticket['cc_address'] ?? null,
+            ]);
+            $segnalazione->meta = $meta;
+
+            if ($beforeCc === $afterCc && $afterCc === []) {
+                $stats['empty']++;
+                if (! $dryRun && $segnalazione->isDirty('meta')) {
+                    Segnalazione::withoutAuditing(function () use ($segnalazione) {
+                        $segnalazione->save();
+                    });
+                }
+                continue;
+            }
+
+            if ($beforeCc === $afterCc && ! $segnalazione->isDirty('bcc')) {
+                $stats['skipped']++;
+                continue;
+            }
+
+            $stats['updated']++;
+            if ($dryRun) {
+                continue;
+            }
+
+            Segnalazione::withoutAuditing(function () use ($segnalazione) {
+                $segnalazione->save();
+            });
+        }
+
+        return $stats;
+    }
+
+    /**
+     * @return list<string>
+     */
+    protected static function normalizeEmailList(mixed $value): array
+    {
+        $emails = Segnalazione::parseEmailList($value);
+        sort($emails);
+
+        return $emails;
+    }
+
     protected function cachedContact(int $contactId): ?array
     {
         if (! array_key_exists($contactId, $this->contactCache)) {

app/Services/SegnalazioneEmailInboxService.php

             $created = true;
         }
 
+        $this->syncCcFromMessage($segnalazione, $message, $fromAddress);
+
         $annotazione = $this->createAnnotazioneFromMessage($segnalazione, $message, $fromAddress, ! $created);
         $this->storeAttachments($segnalazione, $annotazione, $message);
 
         return $personal !== '' ? $personal : ($first->mail ? (string) $first->mail : null);
     }
 
+    protected function syncCcFromMessage(Segnalazione $segnalazione, Message $message, ?string $fromAddress): void
+    {
+        $emails = $this->extractLoopCcEmails($message, $fromAddress);
+        if ($emails === []) {
+            return;
+        }
+
+        $segnalazione->mergeCcEmails($emails, array_filter([(string) $fromAddress]));
+        if ($segnalazione->isDirty('cc')) {
+            $segnalazione->save();
+        }
+    }
+
+    /**
+     * @return list<string>
+     */
+    protected function extractLoopCcEmails(Message $message, ?string $fromAddress): array
+    {
+        $emails = array_merge(
+            $this->extractAddressEmails($message->getCc()),
+            $this->extractAddressEmails($message->getTo()),
+        );
+        $exclude = array_merge(
+            Segnalazione::internalMailboxEmails(),
+            array_filter([strtolower((string) $fromAddress)])
+        );
+
+        return array_values(array_filter(
+            array_unique($emails),
+            static fn (string $email) => ! in_array($email, $exclude, true)
+        ));
+    }
+
+    /**
+     * @return list<string>
+     */
+    protected function extractAddressEmails(mixed $addresses): array
+    {
+        if (! $addresses) {
+            return [];
+        }
+
+        $emails = [];
+        try {
+            foreach ($addresses as $addr) {
+                $mail = is_object($addr) ? ($addr->mail ?? null) : $addr;
+                $mail = strtolower(trim((string) $mail));
+                if ($mail !== '' && filter_var($mail, FILTER_VALIDATE_EMAIL)) {
+                    $emails[] = $mail;
+                }
+            }
+        } catch (\Throwable) {
+            if (is_object($addresses) && method_exists($addresses, 'toString')) {
+                $emails = Segnalazione::parseEmailList($addresses->toString());
+            }
+        }
+
+        return array_values(array_unique($emails));
+    }
+
     protected function alreadyImported(Segnalazione $segnalazione, string $messageId): bool
     {
         $meta = is_array($segnalazione->meta) ? $segnalazione->meta : [];

database/migrations/2026_09_08_090000_add_cc_bcc_to_segnalazione.php

+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('segnalazione', function (Blueprint $table) {
+            $table->json('cc')->nullable()->after('origine');
+            $table->json('bcc')->nullable()->after('cc');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('segnalazione', function (Blueprint $table) {
+            $table->dropColumn(['cc', 'bcc']);
+        });
+    }
+};

resources/views/segnalazione/admin/_cc_bcc_fields.blade.php

+@php
+  $ccValue = $ccValue ?? '';
+  $bccValue = $bccValue ?? '';
+@endphp
+<div class="row g-3" id="wrapSegnalazioneCcBcc">
+  <div class="col-md-6">
+    <label for="segnalazione_cc" class="form-label">CC</label>
+    <input type="text" class="form-control" id="segnalazione_cc" name="cc" value="{{ $ccValue }}" placeholder="indirizzo@esempio.it">
+    <div class="form-text">In copia sulle risposte pubbliche al cliente, come in Redmine.</div>
+  </div>
+  <div class="col-md-6">
+    <label for="segnalazione_bcc" class="form-label">CCN</label>
+    <input type="text" class="form-control" id="segnalazione_bcc" name="bcc" value="{{ $bccValue }}" placeholder="copia nascosta">
+    <div class="form-text">Copia nascosta, non visibile agli altri destinatari.</div>
+  </div>
+</div>

resources/views/segnalazione/admin/nuova.blade.php

 @vite([
 'resources/assets/vendor/libs/datatables-bs5/datatables-bootstrap5.js',
 'resources/assets/vendor/libs/quill/katex.js',
-'resources/assets/vendor/libs/quill/quill.js'
+'resources/assets/vendor/libs/quill/quill.js',
+'resources/assets/vendor/libs/tagify/tagify.js'
 ])
 @endsection
 
 'resources/assets/vendor/libs/datatables-rowgroup-bs5/rowgroup.bootstrap5.scss',
 'resources/assets/vendor/libs/quill/typography.scss',
 'resources/assets/vendor/libs/quill/katex.scss',
-'resources/assets/vendor/libs/quill/editor.scss'
+'resources/assets/vendor/libs/quill/editor.scss',
+'resources/assets/vendor/libs/tagify/tagify.scss'
 ])
 @endsection
 
           </div>
         </div>
 
+        <div class="mb-4">
+          @include('segnalazione.admin._cc_bcc_fields', [
+            'ccValue' => old('cc', ''),
+            'bccValue' => old('bcc', ''),
+          ])
+        </div>
+
         <div class="row g-3 mb-4 align-items-start" id="rowOrdineContratto">
           <div class="col-12 col-lg-6" id="wrapOrdineLavoro">
             <div class="row g-2 align-items-stretch">
 @section('page-script')
 <script type="module">
   $(document).ready(function() {
+    if (typeof window.Tagify === 'function') {
+      ['#segnalazione_cc', '#segnalazione_bcc'].forEach(function (sel) {
+        const el = document.querySelector(sel);
+        if (!el || el.dataset.tagifyReady) return;
+        el.dataset.tagifyReady = '1';
+        new window.Tagify(el, {
+          delimiters: ',|;',
+          duplicates: false,
+          pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+          dropdown: { enabled: 0 },
+          originalInputValueFormat: (values) => values.map((v) => v.value).join(',')
+        });
+      });
+    }
     function initQuillEditor(editorId, toolbarId, hiddenInputId) {
       const editor = new Quill('#' + editorId, {
         bounds: '#' + editorId,

resources/views/segnalazione/admin/show.blade.php

 @vite([
 'resources/assets/vendor/libs/datatables-bs5/datatables-bootstrap5.js',
 'resources/assets/vendor/libs/quill/katex.js',
-'resources/assets/vendor/libs/quill/quill.js'
+'resources/assets/vendor/libs/quill/quill.js',
+'resources/assets/vendor/libs/tagify/tagify.js'
 ])
 @endsection
 
 'resources/assets/vendor/libs/datatables-rowgroup-bs5/rowgroup.bootstrap5.scss',
 'resources/assets/vendor/libs/quill/typography.scss',
 'resources/assets/vendor/libs/quill/katex.scss',
-'resources/assets/vendor/libs/quill/editor.scss'
+'resources/assets/vendor/libs/quill/editor.scss',
+'resources/assets/vendor/libs/tagify/tagify.scss'
 ])
 
 @endsection
               <i class="bx bx-user me-1"></i>
               {{ $segnalazione->user ? $segnalazione->user->full_name : '---' }}
             </div>
+            @php
+              $ccVisibili = $segnalazione->emailDestinatari('cc');
+              $bccVisibili = $isVistaCliente ? [] : $segnalazione->emailDestinatari('bcc');
+            @endphp
+            @if($ccVisibili !== [])
+            <div class="small text-muted mb-1 mt-2">CC</div>
+            <div class="small text-break">{{ implode(', ', $ccVisibili) }}</div>
+            @endif
+            @if($bccVisibili !== [])
+            <div class="small text-muted mb-1 mt-2">CCN</div>
+            <div class="small text-break">{{ implode(', ', $bccVisibili) }}</div>
+            @endif
           </div>
 
           <div class="col-12 col-lg-3">
             </div>
             <div id="quill_annotazione" class="quill-annotazione-editor"></div>
             <div class="form-text mt-1 d-none" id="annotazioneQuoteHint">Citazione stile email già inserita (modificabile). Scrivi la nuova risposta sopra.</div>
+            <div class="mt-3">
+              @include('segnalazione.admin._cc_bcc_fields', [
+                'ccValue' => old('cc', implode(',', \App\Models\Segnalazione::parseEmailList($segnalazione->cc ?? []))),
+                'bccValue' => old('bcc', implode(',', \App\Models\Segnalazione::parseEmailList($segnalazione->bcc ?? []))),
+              ])
+            </div>
           </div>
 
           {{-- 4. Tempo / costo / allegati --}}
       }
     });
 
+    function initSegnalazioneCcBccTagify() {
+      if (typeof window.Tagify !== 'function') return;
+      ['#segnalazione_cc', '#segnalazione_bcc'].forEach(function (sel) {
+        const el = document.querySelector(sel);
+        if (!el || el.dataset.tagifyReady) return;
+        el.dataset.tagifyReady = '1';
+        new window.Tagify(el, {
+          delimiters: ',|;',
+          duplicates: false,
+          pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+          dropdown: { enabled: 0 },
+          originalInputValueFormat: (values) => values.map((v) => v.value).join(',')
+        });
+      });
+    }
+
+    function syncCcBccVisibility() {
+      const riservata = $('#annotazione_riservata').is(':checked');
+      $('#wrapSegnalazioneCcBcc').toggleClass('d-none', riservata);
+    }
+
+    initSegnalazioneCcBccTagify();
+    $('#annotazione_riservata').on('change', syncCcBccVisibility);
+    syncCcBccVisibility();
+
     const statiChiusura = @json(\App\Models\Config::getStatiSegnalazione('chiuse'));
 
     function incompleteObbligatoriTitles() {
       if ($riservata.length) {
         $riservata.prop('checked', !isRispondi);
       }
+      syncCcBccVisibility();
       if ($label.length) {
         $label.text(isRispondi ? 'Rispondi alla segnalazione' : 'Modifica segnalazione');
       }