Surface dead filters, and name board and stacks in the moved-card mail

A filter whose entries have all been deleted from the board was the one
failure mode of this app that was completely invisible: the workflow kept
running, kept updating last_run and matched nothing, forever. It happens
with deleted labels and just as easily when a filtered user loses board
access, because Deck's BoardService::deleteAcl() calls
assignedUsersMapper->deleteByParticipantOnBoard() and wipes that user's
card assignments.

Two low-stakes signals, no new column and no migration:

- WorkflowRunner::warnAboutDeadFilters() logs a warning on every run.
- workflowIssues in PersonalSettings.vue marks the row red.

Deliberately no mail and no `enabled = false`. One deleted label out of
three is harmless, and even a fully dead filter can be one board edit away
from being live again.

Both obey the rule the disable path already follows: only positive
knowledge. DeckIntegrationService::findFilterOptions() therefore throws
instead of degrading to [], unlike listLabels()/listParticipants(), where
an empty list only means an empty dropdown.

That also fixes an existing false positive of the same family:
loadStacksFor() stored [] when the request failed, so a single failed
fetch reported "Quell-Stapel und Ziel-Stapel nicht mehr vorhanden" for an
untouched board. Failed requests now store null and are read as "unknown".

The comparison itself lives in WorkflowRunner::findDeadFilters(), static
and side-effect free like cardMatchesFilters(), with unit tests -- notably
that an empty filter is never dead, which would otherwise flag every
unfiltered workflow.

Separately, the moved-card mail now names the board and both stacks.
DeckIntegrationService::describeTargets() resolves the titles at most once
per workflow run, and only when a card actually moved and the workflow
wants a mail; unreadable titles degrade to #<id> rather than costing the
user their notification.

lib/Service/DeckIntegrationService.php

@@ -315,17 +315,80 @@ class DeckIntegrationService {
 	 * @return array<int, array{id: int, title: string, color: string|null}>
 	 */
 	public function listLabels(int $boardId): array {
-		$labels = $this->call(function () use ($boardId) {
-			$board = $this->resolve(BoardService::class)->find($boardId, true);
-			return $board->getLabels() ?? [];
-		}, []);
+		$labels = $this->call(fn () => $this->readLabels($boardId), []);
 
 		return array_map(
-			static fn ($label) => ['id' => $label->getId(), 'title' => $label->getTitle(), 'color' => $label->getColor()],
+			static fn ($label) => ['id' => (int)$label->getId(), 'title' => $label->getTitle(), 'color' => $label->getColor()],
 			$labels,
 		);
 	}
 
+	/**
+	 * What a workflow's filters *could* legitimately refer to on this board.
+	 *
+	 * Unlike listLabels()/listParticipants() this throws instead of degrading
+	 * to an empty list, because its only caller draws a conclusion from
+	 * emptiness ("this filter cannot match anything any more"). Same rule as
+	 * findStackIds(): a Deck hiccup must never be read as positive knowledge.
+	 *
+	 * @return array{labelIds: int[], participantUids: string[]}
+	 * @throws DeckUnavailableException
+	 */
+	public function findFilterOptions(int $boardId): array {
+		try {
+			$board = $this->readBoard($boardId);
+
+			return [
+				'labelIds' => array_map(
+					static fn ($label) => (int)$label->getId(),
+					$board->getLabels() ?? [],
+				),
+				'participantUids' => array_values(array_unique($this->collectParticipantUids($board))),
+			];
+		} catch (DeckUnavailableException $e) {
+			throw $e;
+		} catch (Throwable $e) {
+			$this->logger->error('Could not read filter options of board ' . $boardId . ': ' . $e->getMessage(), [
+				'app' => 'workflow_deck_automation',
+				'exception' => $e,
+			]);
+			throw new DeckUnavailableException('Deck call failed: ' . $e->getMessage(), 0, $e);
+		}
+	}
+
+	/**
+	 * Titles of a workflow's board and stacks, for the notification mail.
+	 *
+	 * Best effort by design: this only decorates a mail that is being sent
+	 * because a card *was* already moved, so anything unreadable degrades to
+	 * `#<id>` rather than costing the user their notification.
+	 *
+	 * @return array{board: string, sourceStack: string, targetStack: string}
+	 */
+	public function describeTargets(int $boardId, int $sourceStackId, int $targetStackId): array {
+		$titles = $this->call(function () use ($boardId) {
+			$stackTitles = [];
+			foreach ($this->resolve(StackMapper::class)->findAll($boardId) as $stack) {
+				$stackTitles[(int)$stack->getId()] = (string)$stack->getTitle();
+			}
+
+			return [
+				'board' => (string)$this->resolve(BoardMapper::class)->find($boardId)->getTitle(),
+				'stacks' => $stackTitles,
+			];
+		}, ['board' => '', 'stacks' => []]);
+
+		return [
+			'board' => self::titleOr($titles['board'], $boardId),
+			'sourceStack' => self::titleOr($titles['stacks'][$sourceStackId] ?? '', $sourceStackId),
+			'targetStack' => self::titleOr($titles['stacks'][$targetStackId] ?? '', $targetStackId),
+		];
+	}
+
+	private static function titleOr(string $title, int $id): string {
+		return $title !== '' ? $title : ('#' . $id);
+	}
+
 	/**
 	 * Everyone who can hold a card on this board: the board owner (who is
 	 * *not* part of the ACL — a private board has an empty ACL) plus every
@@ -334,32 +397,7 @@ class DeckIntegrationService {
 	 * @return array<int, array{uid: string, displayName: string}>
 	 */
 	public function listParticipants(int $boardId): array {
-		$uids = $this->call(function () use ($boardId) {
-			$board = $this->resolve(BoardService::class)->find($boardId, true);
-
-			$uids = [];
-			$owner = $this->unwrapUid($board->getOwner());
-			if ($owner !== null) {
-				$uids[] = $owner;
-			}
-
-			foreach ($board->getAcl() ?? [] as $entry) {
-				$principal = $this->extractParticipantUid($entry);
-				if ($principal === null) {
-					continue;
-				}
-				$type = method_exists($entry, 'getType') ? (int)$entry->getType() : self::ACL_TYPE_USER;
-				if ($type === self::ACL_TYPE_GROUP) {
-					array_push($uids, ...$this->groupMemberUids($principal));
-				} elseif ($type === self::ACL_TYPE_USER) {
-					$uids[] = $principal;
-				}
-				// Circles and federated shares are skipped: their members
-				// cannot be resolved to plain uids here.
-			}
-
-			return $uids;
-		}, []);
+		$uids = $this->call(fn () => $this->collectParticipantUids($this->readBoard($boardId)), []);
 
 		$participants = [];
 		foreach ($uids as $uid) {
@@ -375,6 +413,47 @@ class DeckIntegrationService {
 		return array_values($participants);
 	}
 
+	/**
+	 * The enriched board — `$fullDetails = true` is what populates labels and
+	 * the ACL. Shared by every caller that needs one so a single Deck read
+	 * serves them all.
+	 */
+	private function readBoard(int $boardId): mixed {
+		return $this->resolve(BoardService::class)->find($boardId, true);
+	}
+
+	private function readLabels(int $boardId): array {
+		return $this->readBoard($boardId)->getLabels() ?? [];
+	}
+
+	/**
+	 * @return string[] may contain duplicates
+	 */
+	private function collectParticipantUids(mixed $board): array {
+		$uids = [];
+		$owner = $this->unwrapUid($board->getOwner());
+		if ($owner !== null) {
+			$uids[] = $owner;
+		}
+
+		foreach ($board->getAcl() ?? [] as $entry) {
+			$principal = $this->extractParticipantUid($entry);
+			if ($principal === null) {
+				continue;
+			}
+			$type = method_exists($entry, 'getType') ? (int)$entry->getType() : self::ACL_TYPE_USER;
+			if ($type === self::ACL_TYPE_GROUP) {
+				array_push($uids, ...$this->groupMemberUids($principal));
+			} elseif ($type === self::ACL_TYPE_USER) {
+				$uids[] = $principal;
+			}
+			// Circles and federated shares are skipped: their members
+			// cannot be resolved to plain uids here.
+		}
+
+		return $uids;
+	}
+
 	/**
 	 * @return string[]
 	 */