@remit/backend 0.0.107 → 0.0.109

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.107",
+  "version": "0.0.109",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/derive/enrichThreadRows.test.ts

@@ -9,7 +9,11 @@ import type {
 } from "@remit/data-ports";
 import { deriveAddressId } from "@remit/data-ports/id";
 import { hasAbandonedDelete } from "@remit/data-ports/message-settlement";
-import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
+import {
+	MessageMutation,
+	MessageStatus,
+	MessageSyncStatus,
+} from "@remit/domain-enums";
 import { type EnrichClient, enrichThreadRows } from "./enrichThreadRows.js";
 
 const threadRow = (
@@ -273,22 +277,45 @@ describe("enrichThreadRows — the mutation pair", () => {
 		return result;
 	};
 
-	test("projects the pair an abandoned delete leaves behind", async () => {
+	test("projects the pair an abandoned delete leaves behind, and what it gave up on", async () => {
 		const result = await project({
 			status: MessageStatus.active,
-			syncStatus: MessageSyncStatus.failed,
+			syncStatus: MessageSyncStatus.abandoned,
+			abandonedMutation: MessageMutation.delete,
 		});
 		assert.equal(result?.status, MessageStatus.active);
-		assert.equal(result?.syncStatus, MessageSyncStatus.failed);
+		assert.equal(result?.syncStatus, MessageSyncStatus.abandoned);
+		assert.equal(result?.abandonedMutation, MessageMutation.delete);
 		assert.equal(
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			true,
 		);
 	});
 
+	// Issue #1229. Both give-ups leave the same `status`/`syncStatus` pair, so
+	// the projection has to carry the third field or the client cannot tell a
+	// move that handed back from a delete that was refused.
+	test("projects a move that gave up as a move, never as a delete", async () => {
+		const result = await project({
+			status: MessageStatus.active,
+			syncStatus: MessageSyncStatus.abandoned,
+			abandonedMutation: MessageMutation.move,
+		});
+		assert.equal(result?.abandonedMutation, MessageMutation.move);
+		assert.equal(
+			hasAbandonedDelete({
+				status: result?.status,
+				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
+			}),
+			false,
+		);
+	});
+
 	test("projects a move mid-retry without calling it a give-up", async () => {
 		const result = await project({
 			status: MessageStatus.moving,
@@ -300,6 +327,7 @@ describe("enrichThreadRows — the mutation pair", () => {
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			false,
 		);
@@ -324,6 +352,7 @@ describe("enrichThreadRows — the mutation pair", () => {
 			hasAbandonedDelete({
 				status: result?.status,
 				syncStatus: result?.syncStatus,
+				abandonedMutation: result?.abandonedMutation,
 			}),
 			false,
 		);

package/src/derive/enrichThreadRows.ts

@@ -8,6 +8,7 @@ import type {
 } from "@remit/data-ports";
 import { deriveAddressId } from "@remit/data-ports/id";
 import {
+	MessageMutation,
 	MessageStatus,
 	MessageSyncStatus,
 	SenderTrust,
@@ -63,6 +64,7 @@ const toResponse = (item: ThreadMessageItem): ThreadMessageResponse => ({
 	muted: false,
 	status: MessageStatus.active,
 	syncStatus: MessageSyncStatus.pending,
+	abandonedMutation: MessageMutation.none,
 });
 
 /**
@@ -110,7 +112,8 @@ export const planBatchFetch = (rows: ThreadMessageItem[]): BatchPlan => {
  * Enrich a page of ThreadMessage rows with `senderTrust` and `muted` (both
  * derived from the From Address's flags map), `authenticity`, `autoMoved` and
  * `spamReport`, and the `status`/`syncStatus` pair an IMAP mutation leaves
- * behind (all projected straight from the Message row — no ThreadMessage
+ * behind together with the mutation an abandoned one names (all projected
+ * straight from the Message row — no ThreadMessage
  * column of their own, see `deriveAutoMoved`). `toResponse` seeds that pair
  * with the ordinary inbound values, which the projection then overwrites; a
  * ThreadMessage row whose Message row is missing from the batch is broken in a
@@ -189,7 +192,11 @@ export const enrichThreadRows = async (
 	const settlementByMessageId = new Map(
 		messages.map((m) => [
 			m.messageId,
-			{ status: m.status, syncStatus: m.syncStatus },
+			{
+				status: m.status,
+				syncStatus: m.syncStatus,
+				abandonedMutation: m.abandonedMutation,
+			},
 		]),
 	);
 	const trustByAddressId = new Map(

package/src/derive/filterThreadCriteria.test.ts

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import type { ThreadMessageResponse } from "@remit/api-openapi-types";
 import {
 	MessageCategory,
+	MessageMutation,
 	MessageStatus,
 	MessageSyncStatus,
 	SenderTrust,
@@ -38,6 +39,7 @@ const row = (
 	muted: false,
 	status: MessageStatus.active,
 	syncStatus: MessageSyncStatus.pending,
+	abandonedMutation: MessageMutation.none,
 	...overrides,
 });
 

package/src/handlers/message.test.ts

@@ -43,7 +43,8 @@ describe("settleSpamReportBulk", () => {
 	});
 
 	// A refusal the move gate raises used to collapse to the generic retry copy,
-	// which is a dead end for the reason no retry clears (#665).
+	// which is a dead end (#665). One reason reaches it now — a mutation still in
+	// flight — and it words the wait rather than the server's sentence.
 	it("words a placement refusal from its reason, never from the server's sentence", async () => {
 		const outcome = await settleSpamReportBulk(
 			["msg-1", "msg-2"],
@@ -52,16 +53,15 @@ describe("settleSpamReportBulk", () => {
 					`Message ${messageId} was not acted on: its folder and uid do not name the same message`,
 					"acc-1",
 					messageId,
-					messageId === "msg-1" ? "in_flight" : "unverified",
+					"in_flight",
 				);
 			},
 		);
 
-		const [inFlight, unverified] = outcome.failures?.map((f) => f.reason) ?? [];
-		assert.match(inFlight ?? "", /try again in a moment/i);
-		assert.match(unverified ?? "", /sync the folder/i);
-		assert.doesNotMatch(unverified ?? "", /try again in a moment/i);
-		for (const reason of [inFlight, unverified]) {
+		const reasons = outcome.failures?.map((f) => f.reason) ?? [];
+		assert.equal(reasons.length, 2);
+		for (const reason of reasons) {
+			assert.match(reason ?? "", /try again in a moment/i);
 			assert.notEqual(reason, GENERIC_FAILURE_REASON);
 			assert.doesNotMatch(reason ?? "", /folder and uid/);
 			assert.doesNotMatch(reason ?? "", /acc-1/);

package/src/handlers/message.ts

@@ -368,17 +368,15 @@ const isDesignedFailure = (reason: unknown): reason is Error =>
 
 /**
  * The placement refusal is the one designed outcome whose own message is not
- * the text to ship: it names a uuid and no remedy, and the two reasons do not
- * share a remedy — an in-flight move settles on its own, an abandoned one only
- * clears once the folder is resynced. Worded here off `details.reason`, the way
- * the delete path words the same refusal for the client.
+ * the text to ship: it names a uuid and no remedy. One remedy answers it, and
+ * only one refusal reaches it — a mutation still in flight, which settles on
+ * its own (imap-mutations R3). Worded here, the way the delete path words the
+ * same refusal for the client.
  */
 const placementRefusalReason = (
-	error: MessagePlacementUnsettledError,
+	_error: MessagePlacementUnsettledError,
 ): string =>
-	error.publicApiError?.details?.reason === "unverified"
-		? "An earlier move of this message never finished, so where it sits is unknown. Sync the folder, then report it again."
-		: "This message is still being moved on the mail server. Try again in a moment.";
+	"This message is still being moved on the mail server. Try again in a moment.";
 
 const failureReason = (reason: unknown): string => {
 	if (!isDesignedFailure(reason)) return GENERIC_FAILURE_REASON;
@@ -479,6 +477,7 @@ export const MessageOperations: Record<
 			authenticity: message.authenticity,
 			status: message.status,
 			syncStatus: message.syncStatus,
+			abandonedMutation: message.abandonedMutation,
 			...(autoMoved ? { autoMoved } : {}),
 			...(labels.length > 0 ? { labels } : {}),
 			...(message.spamReport ? { spamReport: message.spamReport } : {}),
@@ -899,7 +898,7 @@ export const MessageBulkOperations: Record<
 		);
 
 		// MessageMoveService handles: Message + ThreadMessage updates + SQS events
-		await client.messageMove.deleteMessages(
+		const { refusedMessageIds } = await client.messageMove.deleteMessages(
 			accountConfigId,
 			messageIds,
 			accountId,
@@ -908,9 +907,14 @@ export const MessageBulkOperations: Record<
 			},
 		);
 
+		// A row whose placement changed under the batch is reported, not dropped.
+		// The response already carries per-row counts, which is the honest shape
+		// for a batch that partly applied — a 409 over it would deny the deletes
+		// that did happen, and silence leaves the client's optimistic removal to
+		// reappear with nothing said (imap-mutations R3).
 		return {
-			successCount: messageIds.length,
-			failureCount: 0,
+			successCount: messageIds.length - refusedMessageIds.length,
+			failureCount: refusedMessageIds.length,
 		};
 	},
 

package/src/service/create-remit-client.ts

@@ -37,6 +37,7 @@ import {
 	BodySyncQueueService,
 	BodySyncService,
 	createConnection,
+	type FilterConfig,
 	FlagPushService,
 	FlagQueueService,
 	type IImapConnection,
@@ -47,6 +48,7 @@ import {
 	PlacementMoveService,
 	SpamReportService,
 } from "@remit/mailbox-service";
+import { buildFilterConfig } from "@remit/mailbox-service/filter-config";
 import { createSearchService, type SearchService } from "@remit/search-service";
 import {
 	buildEmbeddingServiceFromEnv,
@@ -339,6 +341,39 @@ export const buildSharedDeps = (): RemitClientSharedDeps => {
 	};
 };
 
+// The read-path body backfill (describeMessage / getRawMessage →
+// fetchAndGetBody) materializes a body that was never sync-synced, and must run
+// the account's standing filters the same way the imap-worker's sync path does.
+// Without this, a message a user opens before background body-sync is classified
+// but never filter-evaluated — and once its body is stored the filter-capable
+// sync path skips it, so an explicit standing filter silently never fires (issue
+// #223). Only the explicit user-rule half is wired here; heuristic classifier
+// placement stays on the sync path. It shares `buildFilterConfig` with
+// `sync-message-body.ts`, so both paths embed a candidate message under the same
+// env-selected model that produced the anchors and a semantic (anchor-only)
+// filter fires on either (issue #298). Over the message-management queue's
+// local-first PlacementMoveService; filters stay off when that queue is unset.
+export const buildReadPathFilterConfig = (
+	repositories: RemitClientRepositories,
+): FilterConfig | undefined => {
+	const placementMoveQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+	return buildFilterConfig({
+		filterService: repositories.filter,
+		filterAnchorService: repositories.filterAnchor,
+		messageLabelService: repositories.messageLabel,
+		placementMoveService: placementMoveQueueUrl
+			? new PlacementMoveService({
+					messageService: repositories.message,
+					threadMessageService: repositories.threadMessage,
+					markerService: repositories.placementMove,
+					addressService: repositories.address,
+					mailboxSpecialUseService: repositories.mailboxSpecialUse,
+					sqsQueueUrl: placementMoveQueueUrl,
+				})
+			: undefined,
+	});
+};
+
 // Backend-neutral composition root: given repositories (from any data-ports
 // implementation) and the shared services, wire the domain and queue services
 // and assemble a RemitClient. Imports neither ElectroDB nor Drizzle — the
@@ -354,35 +389,7 @@ export const createRemitClient = (deps: RemitClientDeps): RemitClient => {
 		bodySyncQueue,
 	} = deps;
 
-	// The read-path body backfill (describeMessage / getRawMessage →
-	// fetchAndGetBody) materializes a body that was never sync-synced, and must
-	// run the account's standing filters the same way the imap-worker's sync path
-	// does. Without this, a message a user opens before background body-sync is
-	// classified but never filter-evaluated — and once its body is stored the
-	// filter-capable sync path skips it, so an explicit standing filter silently
-	// never fires (issue #223). Only the explicit user-rule half is wired here;
-	// heuristic classifier placement stays on the sync path. Wired like
-	// `sync-message-body.ts`, over the message-management queue's local-first
-	// PlacementMoveService; filters stay off when that queue is unset.
-	const placementMoveQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
-	const placementMoveService = placementMoveQueueUrl
-		? new PlacementMoveService({
-				messageService: repositories.message,
-				threadMessageService: repositories.threadMessage,
-				markerService: repositories.placementMove,
-				addressService: repositories.address,
-				mailboxSpecialUseService: repositories.mailboxSpecialUse,
-				sqsQueueUrl: placementMoveQueueUrl,
-			})
-		: undefined;
-	const filterConfig = placementMoveService
-		? {
-				filterService: repositories.filter,
-				filterAnchorService: repositories.filterAnchor,
-				messageLabelService: repositories.messageLabel,
-				placementMoveService,
-			}
-		: undefined;
+	const filterConfig = buildReadPathFilterConfig(repositories);
 
 	const flagPushService = new FlagPushService({
 		markerService: repositories.flagPush,

package/src/service/read-path-filter-config.test.ts

@@ -0,0 +1,243 @@
+/**
+ * The read-path body backfill must run a semantic (anchor-only) standing filter,
+ * which needs the env-selected embedder wired into the filter config
+ * `createRemitClient` hands its BodySyncService (issue #298).
+ *
+ * These drive the composed client — `createRemitClient(...).bodySync` — rather
+ * than `buildReadPathFilterConfig` alone, so replacing that call with an inline
+ * filter-config literal (which carries no embedder) fails here.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type {
+	CreateMessageLabelInput,
+	FilterAnchorItem,
+	FilterItem,
+	UpdateMessageInput,
+} from "@remit/data-ports";
+import { NotFoundError } from "@remit/data-ports/errors";
+import { FilterMatchOperator, FilterState } from "@remit/domain-enums";
+import {
+	buildMatchText,
+	type FilterMessage,
+	type IImapConnection,
+	NO_ACTION,
+} from "@remit/mailbox-service";
+import type { SearchService } from "@remit/search-service";
+import { buildEmbeddingServiceFromEnv } from "@remit/search-service/from-env";
+import type { SecretsService } from "@remit/secrets-service";
+import type { StorageService } from "@remit/storage-service";
+import {
+	buildReadPathFilterConfig,
+	createRemitClient,
+	type RemitClientRepositories,
+} from "./create-remit-client.js";
+
+const MESSAGE: FilterMessage = {
+	from: "billing@stripe.com",
+	fromName: "Stripe",
+	subject: "Your receipt",
+	text: "Thanks for your payment",
+	listId: "",
+};
+
+const eml = (message: FilterMessage): Buffer =>
+	Buffer.from(
+		[
+			`From: ${message.fromName} <${message.from}>`,
+			"To: me@example.com",
+			`Subject: ${message.subject}`,
+			"Content-Type: text/plain",
+			"",
+			message.text,
+		].join("\r\n"),
+	);
+
+/**
+ * Anchor-only: no literal clauses, so it matches on the embedding alone. Its
+ * action is a label, which the fake MessageLabel repository below records —
+ * a move would run the real PlacementMoveService against SQS.
+ */
+const anchorOnlyFilter: FilterItem = {
+	filterId: "flt-semantic",
+	accountConfigId: "cfg-1",
+	name: "receipts",
+	scope: "Standing",
+	state: FilterState.Active,
+	hasAnchor: true,
+	ruleChangedAt: 1,
+	matchOperator: FilterMatchOperator.Or,
+	literalClauses: [],
+	actionLabelId: "lbl-receipts",
+	actionMailboxId: NO_ACTION,
+	createdAt: 1,
+	updatedAt: 1,
+} as unknown as FilterItem;
+
+// The read path must embed a candidate message under the same model that wrote
+// the anchors, so an anchor written from this text matches it exactly.
+const anchorFor = async (message: FilterMessage): Promise<FilterAnchorItem> => {
+	const embedding = buildEmbeddingServiceFromEnv();
+	const [anchorEmbedding] = await embedding.embed([buildMatchText(message)]);
+	return {
+		accountConfigId: "cfg-1",
+		filterId: "flt-semantic",
+		anchorEmbedding,
+		anchorEmbeddingId: embedding.embeddingId,
+		anchorSourceText: buildMatchText(message),
+		anchorMessageId: "m-anchor",
+	} as unknown as FilterAnchorItem;
+};
+
+const repositoriesWithAnchor = (
+	anchor: FilterAnchorItem,
+	applied: CreateMessageLabelInput[] = [],
+): RemitClientRepositories =>
+	({
+		filter: {
+			listByAccountAndState: async () => [anchorOnlyFilter],
+			refreshExpiry: async (filter: FilterItem) => filter,
+		},
+		filterAnchor: { get: async () => anchor },
+		messageLabel: {
+			apply: async (input: CreateMessageLabelInput) => {
+				applied.push(input);
+			},
+		},
+		message: {
+			get: async (messageId: string) => ({
+				messageId,
+				mailboxId: "mb-inbox",
+				uid: 1,
+			}),
+			update: async (_messageId: string, _input: UpdateMessageInput) => {},
+		},
+		threadMessage: {
+			findAllByMessageId: async () => [
+				{
+					threadMessageId: "tm-1",
+					sentDate: 1,
+					mailboxId: "mb-inbox",
+					isRead: false,
+					isDeleted: false,
+					hasStars: false,
+					hasAttachment: false,
+				},
+			],
+			update: async () => {},
+		},
+		address: {
+			getAddress: async () => {
+				throw new NotFoundError("Address not found");
+			},
+			incrementInboundCount: async () => {},
+		},
+		envelope: { listBodyParts: async () => [] },
+		placementMove: {},
+		mailboxSpecialUse: {},
+	}) as unknown as RemitClientRepositories;
+
+const storage = {
+	storeMessageBody: async () => ({ uri: "s3://bodies/m-1" }),
+	storeParsedBody: async () => {},
+	listBodyParts: async () => [],
+} as unknown as StorageService;
+
+const readBodyThroughClient = async (
+	repositories: RemitClientRepositories,
+	message: FilterMessage,
+): Promise<void> => {
+	const client = createRemitClient({
+		repositories,
+		storage,
+		search: {} as unknown as SearchService,
+		secrets: {} as unknown as SecretsService,
+		sqsQueueUrl: "https://sqs.eu-west-1.amazonaws.com/0/test",
+		sqsSmtpQueueUrl: "https://sqs.eu-west-1.amazonaws.com/0/test-smtp",
+	});
+	const connection = {
+		openBox: async () => {},
+		fetchMessageBody: async () => eml(message),
+	} as unknown as IImapConnection;
+
+	await client.bodySync.fetchAndGetBody(
+		"m-1",
+		"acc-1",
+		"cfg-1",
+		"INBOX",
+		async () => connection,
+	);
+};
+
+describe("createRemitClient read-path filter config", () => {
+	let previousQueueUrl: string | undefined;
+
+	beforeEach(() => {
+		previousQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+		process.env.SQS_QUEUE_URL_MESSAGE_MGMT =
+			"https://sqs.eu-west-1.amazonaws.com/0/test-message-mgmt";
+	});
+
+	afterEach(() => {
+		if (previousQueueUrl === undefined) {
+			delete process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+			return;
+		}
+		process.env.SQS_QUEUE_URL_MESSAGE_MGMT = previousQueueUrl;
+	});
+
+	it("labels a message an anchor-only filter matches on a read-path backfill", async () => {
+		const applied: CreateMessageLabelInput[] = [];
+
+		await readBodyThroughClient(
+			repositoriesWithAnchor(await anchorFor(MESSAGE), applied),
+			MESSAGE,
+		);
+
+		assert.deepEqual(
+			applied.map(({ labelId, appliedByFilterId }) => ({
+				labelId,
+				appliedByFilterId,
+			})),
+			[{ labelId: "lbl-receipts", appliedByFilterId: "flt-semantic" }],
+		);
+	});
+
+	it("leaves a message the anchor does not match unlabelled", async () => {
+		const applied: CreateMessageLabelInput[] = [];
+
+		await readBodyThroughClient(
+			repositoriesWithAnchor(
+				await anchorFor({
+					...MESSAGE,
+					subject: "Scheduled maintenance window",
+					text: "Our service will be unavailable on Sunday",
+				}),
+				applied,
+			),
+			MESSAGE,
+		);
+
+		assert.deepEqual(applied, []);
+	});
+});
+
+describe("buildReadPathFilterConfig", () => {
+	it("keeps filters off when the message-management queue is unset", async () => {
+		const previous = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+		delete process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+		try {
+			assert.equal(
+				buildReadPathFilterConfig(
+					repositoriesWithAnchor(await anchorFor(MESSAGE)),
+				),
+				undefined,
+			);
+		} finally {
+			if (previous !== undefined) {
+				process.env.SQS_QUEUE_URL_MESSAGE_MGMT = previous;
+			}
+		}
+	});
+});

package/src/service/semantic-capability.ts

@@ -1,4 +1,10 @@
 import { logger } from "@remit/logger-lambda";
+import {
+	_resetEmbeddingCapabilityForTest,
+	isEmbeddingCapabilityAbsence,
+	isEmbeddingCapabilityUnavailable,
+	recordEmbeddingCapabilityAbsence,
+} from "@remit/search-service/capability";
 import { isSelfHostSqlBackend } from "../data-backend.js";
 
 /**
@@ -47,23 +53,20 @@ import { isSelfHostSqlBackend } from "../data-backend.js";
  * instead was considered and rejected — it would fabricate relevance scores and
  * matched-chunk labels for the "Related" UI, and cannot serve the cross-account
  * queries the daily brief issues.
+ *
+ * The error vocabulary and the memoized absence itself live in
+ * `@remit/search-service/capability`, shared with the filter pipeline's semantic
+ * skip: whichever path embeds first is the probe, and the other stops trying.
+ * This module adds the self-host scoping and the operator-facing log.
  */
 
-const CAPABILITY_ABSENCE_CODES = new Set([
-	"ERR_MODULE_NOT_FOUND",
-	"MODULE_NOT_FOUND",
-	"ERR_DLOPEN_FAILED",
-	"ERR_EMBEDDING_MODEL_UNAVAILABLE",
-]);
-
-let semanticUnavailable = false;
-
 /** Test-only reset for the memoized absence. */
 export const _resetSemanticCapabilityForTest = (): void => {
-	semanticUnavailable = false;
+	_resetEmbeddingCapabilityForTest();
 };
 
-export const isSemanticSearchUnavailable = (): boolean => semanticUnavailable;
+export const isSemanticSearchUnavailable = (): boolean =>
+	isEmbeddingCapabilityUnavailable();
 
 /**
  * Whether a failure is this deployment simply not carrying the semantic
@@ -71,11 +74,8 @@ export const isSemanticSearchUnavailable = (): boolean => semanticUnavailable;
  * Records nothing, for the caller that must degrade one operation without
  * disabling `/search/semantic` process-wide.
  */
-export const isSemanticCapabilityAbsence = (error: unknown): boolean => {
-	if (!isSelfHostSqlBackend()) return false;
-	const code = (error as { code?: unknown } | null)?.code;
-	return typeof code === "string" && CAPABILITY_ABSENCE_CODES.has(code);
-};
+export const isSemanticCapabilityAbsence = (error: unknown): boolean =>
+	isSelfHostSqlBackend() && isEmbeddingCapabilityAbsence(error);
 
 /**
  * Classify a semantic-search failure. Returns true — and remembers the
@@ -84,12 +84,12 @@ export const isSemanticCapabilityAbsence = (error: unknown): boolean => {
  */
 export const noteSemanticCapabilityAbsence = (error: unknown): boolean => {
 	if (!isSemanticCapabilityAbsence(error)) return false;
-	if (!semanticUnavailable) {
+	if (!isEmbeddingCapabilityUnavailable()) {
 		logger.warn(
 			{ error: error instanceof Error ? error.message : String(error) },
 			"Semantic search pipeline unavailable in this deployment — serving empty semantic results (see deploy/vps/README.md)",
 		);
 	}
-	semanticUnavailable = true;
+	recordEmbeddingCapabilityAbsence(error);
 	return true;
 };