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[]
 	 */

lib/Service/NotificationMailer.php

@@ -30,7 +30,11 @@ class NotificationMailer {
 	) {
 	}
 
-	public function sendCardMovedNotification(IUser $user, Workflow $workflow, Card $card): void {
+	/**
+	 * @param array{board: string, sourceStack: string, targetStack: string} $targets
+	 *        titles resolved by DeckIntegrationService::describeTargets()
+	 */
+	public function sendCardMovedNotification(IUser $user, Workflow $workflow, Card $card, array $targets): void {
 		$email = $user->getEMailAddress();
 		if ($email === null || $email === '') {
 			$this->logger->info('Skipping notification for workflow ' . $workflow->getId() . ': user ' . $user->getUID() . ' has no email address', [
@@ -55,6 +59,13 @@ class NotificationMailer {
 				'The card "%1$s" was moved because it is overdue (workflow "%2$s").',
 				[$card->getTitle(), $workflow->getTitle()],
 			));
+			// Single-argument addBodyText() runs htmlspecialchars() itself, so
+			// these board- and stack-titles (user input) are safe as-is —
+			// unlike the description below, which passes both parts.
+			$template->addBodyText($this->l10n->t(
+				'Board "%1$s": moved from "%2$s" to "%3$s".',
+				[$targets['board'], $targets['sourceStack'], $targets['targetStack']],
+			));
 			$this->addCardDescription($template, $card);
 			$template->addBodyButton($this->l10n->t('Open card'), $cardLink);
 			$template->addFooter();

lib/Service/WorkflowRunner.php

@@ -159,6 +159,11 @@ class WorkflowRunner {
 
 		$filterUserIds = $workflow->getFilterUserIdsArray();
 		$filterLabelIds = $workflow->getFilterLabelIdsArray();
+		$this->warnAboutDeadFilters($workflow, $filterUserIds, $filterLabelIds);
+
+		// Resolved at most once per run, and only if a card actually moves
+		// and the workflow wants a mail — this is decoration, not a check.
+		$targets = null;
 
 		foreach ($cards as $card) {
 			if (!self::isOverdue($card->getDaysUntilDue())) {
@@ -171,7 +176,18 @@ class WorkflowRunner {
 				continue;
 			}
 
-			$this->moveAndNotify($user, $workflow, $card);
+			if (!$this->moveCard($workflow, $card)) {
+				continue;
+			}
+
+			if ($workflow->getNotifyEmail()) {
+				$targets ??= $this->deckService->describeTargets(
+					$workflow->getBoardId(),
+					$workflow->getSourceStackId(),
+					$workflow->getTargetStackId(),
+				);
+				$this->mailer->sendCardMovedNotification($user, $workflow, $card, $targets);
+			}
 		}
 
 		$workflow->setLastRun($this->timeFactory->getDateTime());
@@ -226,7 +242,7 @@ class WorkflowRunner {
 		$this->mailer->sendWorkflowDisabledNotification($user, $workflow, $brokenTarget);
 	}
 
-	private function moveAndNotify(IUser $user, Workflow $workflow, Card $card): void {
+	private function moveCard(Workflow $workflow, Card $card): bool {
 		try {
 			$this->deckService->moveCard($card->getId(), $workflow->getTargetStackId());
 		} catch (Throwable $e) {
@@ -235,11 +251,55 @@ class WorkflowRunner {
 				'card' => $card->getId(),
 				'id' => $workflow->getId(),
 			]);
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * A filter whose every entry has been deleted from the board is not an
+	 * error — the workflow still runs, it just cannot match a single card any
+	 * more, forever, without anything in the UI or the log saying so. That is
+	 * the one failure mode of this app that is completely invisible, so it
+	 * gets a log line on every run.
+	 *
+	 * Explicitly *not* a reason to disable the workflow or mail the user: a
+	 * filter with three labels of which one was deleted still works as
+	 * intended, and even a fully dead filter may be one board edit away from
+	 * being live again. The settings page shows the same condition in red.
+	 *
+	 * @param string[] $filterUserIds
+	 * @param int[] $filterLabelIds
+	 */
+	private function warnAboutDeadFilters(Workflow $workflow, array $filterUserIds, array $filterLabelIds): void {
+		if ($filterUserIds === [] && $filterLabelIds === []) {
 			return;
 		}
 
-		if ($workflow->getNotifyEmail()) {
-			$this->mailer->sendCardMovedNotification($user, $workflow, $card);
+		try {
+			$options = $this->deckService->findFilterOptions($workflow->getBoardId());
+		} catch (DeckUnavailableException $e) {
+			// Same rule as everywhere else: no answer is not a bad answer.
+			$this->logger->debug('Could not check the filters of workflow {id}: ' . $e->getMessage(), [
+				'app' => 'workflow_deck_automation',
+				'id' => $workflow->getId(),
+			]);
+			return;
+		}
+
+		$dead = self::findDeadFilters($filterUserIds, $filterLabelIds, $options['participantUids'], $options['labelIds']);
+
+		if ($dead !== []) {
+			$this->logger->warning(
+				'Workflow {id} can no longer match any card: none of its ' . implode('/', $dead)
+				. ' filter entries exists on board {board} any more',
+				[
+					'app' => 'workflow_deck_automation',
+					'id' => $workflow->getId(),
+					'board' => $workflow->getBoardId(),
+				],
+			);
 		}
 	}
 
@@ -247,6 +307,38 @@ class WorkflowRunner {
 		return $daysUntilDue !== null && $daysUntilDue < 0;
 	}
 
+	/**
+	 * Which filters cannot match anything any more, because not one of their
+	 * entries is still offered by the board. An empty filter is not dead, it
+	 * is "no restriction on this dimension" — the same reading as in
+	 * cardMatchesFilters(), and getting it backwards would report every
+	 * unfiltered workflow as broken.
+	 *
+	 * Static and side-effect free for the same reason as the matching logic:
+	 * testable without a Deck installation.
+	 *
+	 * @param string[] $filterUserIds
+	 * @param int[] $filterLabelIds
+	 * @param string[] $boardUserIds everyone who can hold a card on the board
+	 * @param int[] $boardLabelIds the board's remaining labels
+	 * @return string[] any of 'label', 'user', in that order
+	 */
+	public static function findDeadFilters(
+		array $filterUserIds,
+		array $filterLabelIds,
+		array $boardUserIds,
+		array $boardLabelIds,
+	): array {
+		$dead = [];
+		if ($filterLabelIds !== [] && array_intersect($filterLabelIds, $boardLabelIds) === []) {
+			$dead[] = 'label';
+		}
+		if ($filterUserIds !== [] && array_intersect($filterUserIds, $boardUserIds) === []) {
+			$dead[] = 'user';
+		}
+		return $dead;
+	}
+
 	/**
 	 * Pure filter-matching logic (kept static/side-effect free so it can
 	 * be unit tested without real Deck objects). Both filters are OR