@remit/backend 0.0.138 → 0.0.139

package/package.json

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

package/src/handlers/filter.test.ts

@@ -1,11 +1,13 @@
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { afterEach, describe, it, mock } from "node:test";
+import type { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type {
 	CreateFilterInput,
 	UpdateFilterInput as UpdateFilterRequestBody,
 } from "@remit/api-openapi-types";
 import type {
 	CreateFilterAnchorInput,
+	CreateOrganizeJobRequestInput,
 	CreateFilterInput as FilterAnchorTxCreateInput,
 	FilterItem,
 } from "@remit/data-ports";
@@ -16,9 +18,19 @@ import {
 	FilterState,
 } from "@remit/domain-enums";
 import type { AnchorPayload } from "@remit/search-service";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import { deriveAccountConfigId } from "../auth.js";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "../service/data-client.js";
+import { sqsClient } from "../service/sqs.js";
 import {
 	createFilterWithAnchor,
 	type FilterCrudDeps,
+	FilterOperations,
 	pickFilterUpdate,
 	rejectAnchorMutation,
 	resolveFilterScopeExpiry,
@@ -516,3 +528,117 @@ describe("createFilterWithAnchor (#351)", () => {
 		);
 	});
 });
+
+describe("createFilter queues the new filter's pass over the inbox (#1354)", () => {
+	const SUB = "cognito-sub-1354";
+	const ACCOUNT_CONFIG_ID = deriveAccountConfigId(SUB);
+	const ACCOUNT_ID = "acc-1354";
+
+	const created: FilterItem = {
+		filterId: "flt-new",
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		name: "Invoices",
+		scope: FilterScope.Standing,
+		state: FilterState.Active,
+		disabledReason: "None",
+		hasAnchor: false,
+		ruleChangedAt: 1,
+		actionChangedAt: 1,
+		matchOperator: FilterMatchOperator.And,
+		literalClauses: [{ field: "From", value: "billing@example.com" }],
+		actionLabelId: "None",
+		actionMailboxId: "mbx-invoices",
+		createdAt: 0,
+		updatedAt: 0,
+	};
+
+	afterEach(() => {
+		mock.restoreAll();
+		_resetForTest();
+	});
+
+	const world = (filter: FilterItem) => {
+		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+			"http://localhost:9324/queue/account-fanout-test";
+		const jobs: CreateOrganizeJobRequestInput[] = [];
+		const enqueued: SendMessageCommand[] = [];
+		mock.method(sqsClient, "send", async (command: SendMessageCommand) => {
+			enqueued.push(command);
+			return {};
+		});
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			mailbox: {
+				get: async () => ({
+					mailboxId: "mbx-invoices",
+					accountId: ACCOUNT_ID,
+					fullPath: "Invoices",
+					syncStatus: "synced",
+				}),
+			},
+			filterAnchorTransaction: { createWithAnchor: async () => filter },
+			organizeJobRequest: {
+				create: async (input: CreateOrganizeJobRequestInput) => {
+					jobs.push(input);
+					return { ...input, organizeJobId: "job-new", state: "Pending" };
+				},
+			},
+		} as unknown as RemitClient);
+		return { jobs, enqueued };
+	};
+
+	const createFilter = (body: Partial<CreateFilterInput>) =>
+		(
+			FilterOperations.FilterOperations_createFilter as (
+				context: Context,
+				event: APIGatewayProxyEvent,
+			) => Promise<Record<string, unknown>>
+		)(
+			{
+				request: {
+					params: { accountId: ACCOUNT_ID },
+					requestBody: {
+						name: created.name,
+						scope: created.scope,
+						matchOperator: created.matchOperator,
+						literalClauses: created.literalClauses,
+						actionLabelId: created.actionLabelId,
+						actionMailboxId: created.actionMailboxId,
+						...body,
+					},
+				},
+			} as unknown as Context,
+			{
+				requestContext: { authorizer: { claims: { sub: SUB } } },
+			} as unknown as APIGatewayProxyEvent,
+		);
+
+	it("queues an organize job for the created filter and returns its id", async () => {
+		const { jobs, enqueued } = world(created);
+
+		const response = await createFilter({});
+
+		assert.equal(jobs.length, 1);
+		assert.equal(jobs[0]?.filterId, "flt-new");
+		assert.equal(enqueued.length, 1);
+		assert.match(String(enqueued[0]?.input.MessageBody), /job-new/);
+		assert.equal(response.organizeJobId, "job-new");
+		assert.equal(response.filterId, "flt-new");
+	});
+
+	it("names only the filter: the predicate columns stay at their sentinels", async () => {
+		const { jobs } = world(created);
+
+		await createFilter({});
+
+		assert.equal(jobs[0]?.anchorMessageId, "None");
+		assert.deepEqual(jobs[0]?.literalClauses, []);
+		assert.equal(jobs[0]?.actionLabelId, "None");
+		assert.equal(jobs[0]?.actionMailboxId, "None");
+	});
+});

package/src/handlers/filter.ts

@@ -1,5 +1,6 @@
 import type {
 	CreateFilterInput,
+	CreateFilterResponse,
 	FilterResponse,
 	UpdateFilterInput as UpdateFilterRequestBody,
 } from "@remit/api-openapi-types";
@@ -19,9 +20,10 @@ import {
 } from "@remit/domain-enums";
 import type { AnchorPayload } from "@remit/search-service";
 import type { APIGatewayProxyEvent } from "aws-lambda";
-import { getAccountConfigIdFromEvent } from "../auth.js";
+import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
 import { getClient } from "../service/data-client.js";
 import { buildFilterAnchor } from "../service/filter.js";
+import { queueOrganizeJob } from "../service/organize-queue.js";
 import type {
 	FilterDetailOperationIds,
 	FilterOperationIds,
@@ -340,6 +342,16 @@ export const createFilterWithAnchor = async (
 	);
 };
 
+const requireUserId = (event: APIGatewayProxyEvent): string => {
+	const userId = getSubFromEvent(event);
+	if (!userId) {
+		throw new Error(
+			"Missing Cognito `sub`: cannot attribute an organize job to a user",
+		);
+	}
+	return userId;
+};
+
 /**
  * A filter's `actionMailboxId` is a durable reference, so its target has to be
  * a folder the mail server has settled (D12, first row) — 422 otherwise. The
@@ -393,11 +405,15 @@ export const FilterOperations: Record<
 		};
 	},
 
-	FilterOperations_createFilter: async (context, ...args: unknown[]) => {
+	FilterOperations_createFilter: async (
+		context,
+		...args: unknown[]
+	): Promise<CreateFilterResponse> => {
 		const event = args[0] as APIGatewayProxyEvent;
 		const accountConfigId = getAccountConfigIdFromEvent(event);
 		const { accountId } = context.request.params as { accountId: string };
 		const input = context.request.requestBody as CreateFilterInput;
+		const userId = requireUserId(event);
 
 		const client = await getClient();
 		const account = await client.account.get(accountId);
@@ -412,7 +428,14 @@ export const FilterOperations: Record<
 			accountConfigId,
 			input,
 		);
-		return toFilterResponse(filter);
+		// The new filter's first pass over the inbox. The worker reads the filter
+		// when it runs and refuses one that has nothing to run (#1354).
+		const job = await queueOrganizeJob(client, {
+			accountConfigId,
+			userId,
+			filterId: filter.filterId,
+		});
+		return { ...toFilterResponse(filter), organizeJobId: job.organizeJobId };
 	},
 };
 

package/src/handlers/mailbox-settled-target.test.ts

@@ -9,7 +9,7 @@
  * only removed by the user, so a `mailboxId` that names nothing never exists.
  */
 import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
+import { afterEach, describe, it, mock } from "node:test";
 import type { MailboxItem } from "@remit/data-ports";
 import { CanonicalMailboxRole, MailboxSyncStatus } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
@@ -20,6 +20,7 @@ import {
 	type RemitClient,
 	setClient,
 } from "../service/data-client.js";
+import { sqsClient } from "../service/sqs.js";
 import { FilterDetailOperations, FilterOperations } from "./filter.js";
 import { FolderRoleOperations } from "./folder-role.js";
 import { MessageBulkOperations } from "./message.js";
@@ -55,6 +56,9 @@ const world = (syncStatus: MailboxItem["syncStatus"]): Writes => {
 		copies: [],
 	};
 	const row = target(syncStatus);
+	process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+		"http://localhost:9324/queue/account-fanout-test";
+	mock.method(sqsClient, "send", async () => ({}));
 
 	setClient({
 		account: {
@@ -85,6 +89,13 @@ const world = (syncStatus: MailboxItem["syncStatus"]): Writes => {
 				return { filterId: "flt-1" };
 			},
 		},
+		organizeJobRequest: {
+			create: async (input: Record<string, unknown>) => ({
+				...input,
+				organizeJobId: "job-1",
+				state: "Pending",
+			}),
+		},
 		accountSetting: {
 			get: async () => null,
 			upsert: async (item: unknown) => {
@@ -168,6 +179,7 @@ const SITES = [
 
 describe("a write that binds to a folder requires a settled folder", () => {
 	afterEach(() => {
+		mock.restoreAll();
 		_resetForTest();
 	});
 

package/src/handlers/organize.test.ts

@@ -4,11 +4,12 @@ import type { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type { OrganizeInput } from "@remit/api-openapi-types";
 import type {
 	CreateOrganizeJobRequestInput,
+	FilterItem,
 	IAccountRepository,
 	IOrganizeJobRequestRepository,
 	OrganizeJobRequestItem,
 } from "@remit/data-ports";
-import { BadRequestError } from "@remit/data-ports/errors";
+import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { FilterMatchOperator } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
 import type { Context } from "openapi-backend";
@@ -186,3 +187,91 @@ describe("createOrganizeJob rejected-rule refusal (reader #995)", () => {
 		);
 	});
 });
+
+describe("createOrganizeJob by filterId — Run now (#1354)", () => {
+	afterEach(() => {
+		mock.restoreAll();
+		_resetForTest();
+	});
+
+	const standing = (state: FilterItem["state"]): FilterItem => ({
+		filterId: "flt-1",
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		name: "Invoices",
+		scope: "Standing",
+		state,
+		disabledReason: state === "Active" ? "None" : "UserDisabled",
+		hasAnchor: false,
+		ruleChangedAt: 1,
+		actionChangedAt: 1,
+		matchOperator: FilterMatchOperator.And,
+		literalClauses: [{ field: "From", value: "billing@example.com" }],
+		actionLabelId: "None",
+		actionMailboxId: "mbx-invoices",
+		createdAt: 0,
+		updatedAt: 0,
+	});
+
+	const withFilter = (filter: FilterItem): void => {
+		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
+			"http://localhost:9324/queue/account-fanout-test";
+		enqueued.length = 0;
+		createdRows.length = 0;
+		mock.method(sqsClient, "send", async (command: SendMessageCommand) => {
+			enqueued.push(command);
+			return {};
+		});
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			filter: {
+				get: async () => filter,
+			},
+			organizeJobRequest: {
+				create: async (row: CreateOrganizeJobRequestInput) => {
+					createdRows.push(row);
+					return { ...row, organizeJobId: "job-run", state: "Pending" };
+				},
+			},
+		} as unknown as RemitClient);
+	};
+
+	it("queues a job that names only the filter", async () => {
+		withFilter(standing("Active"));
+
+		const response = await postOrganize(input({ filterId: "flt-1" }));
+
+		assert.equal(response.statusCode, 202);
+		assert.equal(createdRows[0]?.filterId, "flt-1");
+		assert.equal(createdRows[0]?.actionMailboxId, "None");
+		assert.deepEqual(createdRows[0]?.literalClauses, []);
+		assert.equal(enqueued.length, 1);
+	});
+
+	it("answers an unknown filter with a 404 and queues nothing", async () => {
+		withFilter(standing("Active"));
+		setClient({
+			account: {
+				get: async () => ({
+					accountId: ACCOUNT_ID,
+					accountConfigId: ACCOUNT_CONFIG_ID,
+				}),
+			},
+			filter: {
+				get: async () => {
+					throw new NotFoundError("Filter not found: flt-gone");
+				},
+			},
+		} as unknown as RemitClient);
+
+		const response = await postOrganize(input({ filterId: "flt-gone" }));
+
+		assert.equal(response.statusCode, 404);
+		assert.deepEqual(createdRows, []);
+		assert.deepEqual(enqueued, []);
+	});
+});

package/src/handlers/organize.ts

@@ -1,4 +1,3 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type {
 	CreateOrganizeJobResponse,
 	OrganizeInput,
@@ -6,9 +5,7 @@ import type {
 	OrganizePreviewResponse,
 } from "@remit/api-openapi-types";
 import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
-import { logger } from "@remit/logger-lambda";
 import type { APIGatewayProxyEvent } from "aws-lambda";
-import { env } from "expect-env";
 import type { Context } from "openapi-backend";
 import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
 import { getClient, type RemitClient } from "../service/data-client.js";
@@ -19,7 +16,10 @@ import {
 	type OrganizePredicate,
 	organizePredicateRejection,
 } from "../service/organize.js";
-import { sqsClient } from "../service/sqs.js";
+import {
+	type OrganizeJobRequest,
+	queueOrganizeJob,
+} from "../service/organize-queue.js";
 import type {
 	OperationHandler,
 	OrganizeJobDetailOperationIds,
@@ -29,13 +29,6 @@ import { assertAccountOwnership } from "./account-ownership.js";
 
 const NONE = "None";
 
-/**
- * How long a finished (or abandoned) job row lingers before the table-wide TTL
- * reclaims it (RFC 034 Decision 1). A back-apply runs once and needs no standing
- * lifetime; a week is ample for a client to poll the result.
- */
-const ORGANIZE_JOB_TTL_SECONDS = 7 * 24 * 60 * 60;
-
 /**
  * Normalize the request body into the flattened predicate the job row and the
  * matcher share. `anchorMessageId` collapses to the `"None"` sentinel when
@@ -70,6 +63,7 @@ const toOrganizeJobResponse = (
 	accountConfigId: job.accountConfigId,
 	userId: job.userId,
 	state: job.state,
+	filterId: job.filterId,
 	anchorMessageId: job.anchorMessageId,
 	matchOperator: job.matchOperator,
 	literalClauses: job.literalClauses,
@@ -84,6 +78,27 @@ const toOrganizeJobResponse = (
 	updatedAt: job.updatedAt,
 });
 
+/**
+ * What a create asks the worker to run. A saved filter is named and read when
+ * the job runs, so Run now and a filter's create share one path (#1354); an
+ * "all like these" predicate the matcher can never honour is answered here,
+ * not with a 202 the worker has to fail later (reader #463).
+ */
+const requestedJob = async (
+	client: RemitClient,
+	owner: { accountConfigId: string; userId: string },
+	input: OrganizeInput,
+): Promise<OrganizeJobRequest> => {
+	if (input.filterId) {
+		await client.filter.get(owner.accountConfigId, input.filterId);
+		return { ...owner, filterId: input.filterId };
+	}
+	const predicate = predicateFromInput(input);
+	const rejection = organizePredicateRejection(predicate);
+	if (rejection) throw new BadRequestError(rejection.message);
+	return { ...owner, predicate };
+};
+
 export const OrganizeOperations: Record<
 	OrganizeOperationIds,
 	OperationHandler<OrganizeOperationIds>
@@ -107,42 +122,9 @@ export const OrganizeOperations: Record<
 		const client = await getClient();
 		await assertAccount(client, accountId, accountConfigId, "act");
 
-		const predicate = predicateFromInput(input);
-
-		// A rule the matcher can never honour is answered here, not with a 202
-		// the worker has to fail later (reader #463).
-		const rejection = organizePredicateRejection(predicate);
-		if (rejection) throw new BadRequestError(rejection.message);
-
-		const ttl = Math.floor(Date.now() / 1000) + ORGANIZE_JOB_TTL_SECONDS;
-
-		const job = await client.organizeJobRequest.create({
-			accountConfigId,
-			userId,
-			anchorMessageId: predicate.anchorMessageId,
-			matchOperator: predicate.matchOperator,
-			literalClauses: predicate.literalClauses,
-			similarityThreshold: predicate.similarityThreshold,
-			actionLabelId: predicate.actionLabelId,
-			actionMailboxId: predicate.actionMailboxId,
-			ttl,
-		});
-
-		await sqsClient.send(
-			new SendMessageCommand({
-				QueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
-				MessageBody: JSON.stringify({
-					type: "OrganizeJob",
-					accountConfigId,
-					organizeJobId: job.organizeJobId,
-				}),
-			}),
-		);
-
-		// biome-ignore lint/plugin/no-logger-info: a back-apply is an audit-grade signal
-		logger.info(
-			{ accountConfigId, organizeJobId: job.organizeJobId },
-			"Organize back-apply job initiated",
+		const job = await queueOrganizeJob(
+			client,
+			await requestedJob(client, { accountConfigId, userId }, input),
 		);
 
 		return {
@@ -164,6 +146,11 @@ export const OrganizeOperations: Record<
 		const client = await getClient();
 		await assertAccount(client, accountId, accountConfigId, "read");
 
+		if (input.filterId) {
+			throw new BadRequestError(
+				"Preview takes a rule, not a saved filter. Run the filter to apply it.",
+			);
+		}
 		const result = await matchOrganize(
 			buildOrganizeMatchDeps(client),
 			accountConfigId,

package/src/service/organize-queue.ts

@@ -0,0 +1,98 @@
+import { SendMessageCommand } from "@aws-sdk/client-sqs";
+import type {
+	CreateOrganizeJobRequestInput,
+	OrganizeJobRequestItem,
+} from "@remit/data-ports";
+import { FilterMatchOperator } from "@remit/domain-enums";
+import { logger } from "@remit/logger-lambda";
+import {
+	DEFAULT_SEMANTIC_MATCH_THRESHOLD,
+	NO_ACTION,
+} from "@remit/mailbox-service";
+import { env } from "expect-env";
+import type { RemitClient } from "./data-client.js";
+import type { OrganizePredicate } from "./organize.js";
+import { sqsClient } from "./sqs.js";
+
+/**
+ * How long a finished (or abandoned) job row lingers before the table-wide TTL
+ * reclaims it (RFC 034 Decision 1). A back-apply runs once and needs no standing
+ * lifetime; a week is ample for a client to poll the result.
+ */
+const ORGANIZE_JOB_TTL_SECONDS = 7 * 24 * 60 * 60;
+
+interface JobOwner {
+	accountConfigId: string;
+	userId: string;
+}
+
+/**
+ * An "all like these" pass carries its predicate; a filter job names only the
+ * filter, which the worker reads when it runs.
+ */
+export type OrganizeJobRequest = JobOwner &
+	({ predicate: OrganizePredicate } | { filterId: string });
+
+/** A filter job's row: the filter id, every predicate column at its sentinel. */
+const filterJobColumns = (
+	filterId: string,
+): Omit<CreateOrganizeJobRequestInput, keyof JobOwner | "ttl"> => ({
+	filterId,
+	anchorMessageId: NO_ACTION,
+	matchOperator: FilterMatchOperator.And,
+	literalClauses: [],
+	similarityThreshold: DEFAULT_SEMANTIC_MATCH_THRESHOLD,
+	actionLabelId: NO_ACTION,
+	actionMailboxId: NO_ACTION,
+});
+
+const predicateColumns = (
+	predicate: OrganizePredicate,
+): Omit<CreateOrganizeJobRequestInput, keyof JobOwner | "ttl"> => ({
+	filterId: NO_ACTION,
+	...predicate,
+});
+
+/**
+ * Write a Pending job row and hand it to the account-fanout worker. Every
+ * back-apply goes through here: "all like these", a new filter's first pass,
+ * and Run now on a saved filter.
+ */
+export const queueOrganizeJob = async (
+	client: Pick<RemitClient, "organizeJobRequest">,
+	request: OrganizeJobRequest,
+): Promise<OrganizeJobRequestItem> => {
+	const { accountConfigId, userId } = request;
+	const columns =
+		"filterId" in request
+			? filterJobColumns(request.filterId)
+			: predicateColumns(request.predicate);
+	const job = await client.organizeJobRequest.create({
+		accountConfigId,
+		userId,
+		...columns,
+		ttl: Math.floor(Date.now() / 1000) + ORGANIZE_JOB_TTL_SECONDS,
+	});
+
+	await sqsClient.send(
+		new SendMessageCommand({
+			QueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+			MessageBody: JSON.stringify({
+				type: "OrganizeJob",
+				accountConfigId,
+				organizeJobId: job.organizeJobId,
+			}),
+		}),
+	);
+
+	// biome-ignore lint/plugin/no-logger-info: a back-apply is an audit-grade signal
+	logger.info(
+		{
+			accountConfigId,
+			organizeJobId: job.organizeJobId,
+			filterId: job.filterId,
+		},
+		"Organize back-apply job initiated",
+	);
+	return job;
+};

package/src/service/organize.test.ts

@@ -289,6 +289,7 @@ const matchDeps = (
 		},
 		listAccountFilterMessages: async () => ({ items: corpus }),
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => filterAnchorRows,
 			put: async () => {
 				throw new Error("matchDeps must not repair an anchor");
@@ -330,6 +331,7 @@ const vectorlessDeps = (
 		},
 		listAccountFilterMessages: async () => ({ items: corpus }),
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => [],
 			put: async () => {
 				throw moduleNotFound();
@@ -471,6 +473,7 @@ describe("matchOrganize honors the persisted FilterAnchor (reader #350)", () =>
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [persistedAnchor],
 				put: async () => {
 					throw new Error("a current anchor must not be rewritten");
@@ -757,6 +760,7 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [drifted],
 				put: async () => {
 					throw new Error("an unrepairable anchor must not be rewritten");
@@ -798,6 +802,7 @@ describe("matchOrganize on a deployment without the vector pipeline", () => {
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => [],
 				put: async () => {
 					throw new Error("unreachable");
@@ -1120,6 +1125,7 @@ describe("back-apply repairs a drifted anchor the way index-time matching does (
 			}),
 			listAccountFilterMessages: async () => ({ items: [] }),
 			filterAnchors: {
+				get: async () => null,
 				listByAccountConfig: async () => anchors,
 				put: async (input: CreateFilterAnchorInput) => {
 					anchorPuts.push(input);
@@ -1319,6 +1325,7 @@ const storeBackedDeps = (
 			};
 		},
 		filterAnchors: {
+			get: async () => null,
 			listByAccountConfig: async () => [],
 			put: async () => {
 				throw new Error("unreachable");

package/src/service/organize.ts

@@ -5,18 +5,22 @@ import type {
 	IFilterAnchorRepository,
 	OrganizeJobRequestItem,
 } from "@remit/data-ports";
-import { FilterClauseField } from "@remit/domain-enums";
+import { NotFoundError } from "@remit/data-ports/errors";
+import { FilterClauseField, FilterState } from "@remit/domain-enums";
 import { logger } from "@remit/logger-lambda";
 import {
 	DEFAULT_SEMANTIC_MATCH_THRESHOLD,
 	type FilterMessage,
+	FilterPipeline,
 	type LiteralClauseNarrowing,
 	literalClausesMatch,
 	literalClauseTerms,
+	type MessageEmbedder,
 	NO_ACTION,
 	PlacementMoveService,
 	refreshAnchorForEmbedder,
 } from "@remit/mailbox-service";
+import { buildFilterConfig } from "@remit/mailbox-service/filter-config";
 import {
 	type AnchorPayload,
 	buildMessageAnchor,
@@ -135,6 +139,18 @@ export interface OrganizeCandidatePage {
 export interface OrganizeCandidateQuery extends LiteralClauseNarrowing {
 	limit: number;
 	continuationToken?: string;
+	mailboxIds?: readonly string[];
+}
+
+/**
+ * Where a pass looks and which standing filter it runs for. A filter
+ * back-apply reads that filter's own FilterAnchor row by id, narrows both the
+ * literal corpus and the vector query to the inbox, and matches a body-content
+ * clause on the stored preview; an "all like these" pass sets neither.
+ */
+export interface OrganizeMatchScope {
+	filterId?: string;
+	mailboxIds?: readonly string[];
 }
 
 export interface OrganizeMatchDeps {
@@ -159,16 +175,19 @@ export interface OrganizeMatchDeps {
 	/**
 	 * Every persisted FilterAnchor for the account — read-only, always
 	 * available (never gated behind {@link semantic}, since it never touches
-	 * the vector store). A back-apply predicate carries only a bare
-	 * `anchorMessageId`, never a `filterId` (RFC 034 recap: this job is
-	 * deliberately not a Filter), so this is how {@link matchSemantic} finds
-	 * "the standing filter this anchor came from," if one still exists, to
-	 * read its fixed-at-save-time vector instead of re-deriving one from the
-	 * anchor message's current chunks (reader #350 / RFC 039 Decision 1).
+	 * the vector store). A filter back-apply reads its own row by `filterId`
+	 * (#1354); an "all like these" predicate carries only a bare
+	 * `anchorMessageId`, so this is how {@link matchSemantic} finds "the
+	 * standing filter this anchor came from," if one still exists, to read its
+	 * fixed-at-save-time vector instead of re-deriving one from the anchor
+	 * message's current chunks (reader #350 / RFC 039 Decision 1).
 	 * `put` is the write half of the lazy anchor-drift repair
 	 * ({@link refreshAnchorForEmbedder}), never a new standing rule.
 	 */
-	filterAnchors: Pick<IFilterAnchorRepository, "listByAccountConfig" | "put">;
+	filterAnchors: Pick<
+		IFilterAnchorRepository,
+		"get" | "listByAccountConfig" | "put"
+	>;
 }
 
 /**
@@ -179,7 +198,10 @@ export interface OrganizeMatchDeps {
  * make it (reader #463).
  */
 export interface OrganizeRejection {
-	reason: "BodyContentWithoutVectorPipeline";
+	reason:
+		| "BodyContentWithoutVectorPipeline"
+		| "FilterNotActive"
+		| "FilterMissing";
 	message: string;
 }
 
@@ -246,9 +268,9 @@ const filterMessageFromChunks = (
 /**
  * The persisted FilterAnchor whose `anchorMessageId` matches this predicate's
  * anchor, if the account has a standing filter built from that message (RFC
- * 034 Decision 2 / RFC 039 Decision 1, reader #350). A back-apply predicate
- * never carries a `filterId` — this job structurally is not a Filter — so the
- * only way to recover "the filter this anchor came from" is by the value it
+ * 034 Decision 2 / RFC 039 Decision 1, reader #350). An "all like these"
+ * predicate carries no `filterId` — that job structurally is not a Filter — so
+ * the only way to recover "the filter this anchor came from" is by the value it
  * was anchored on. The scan is over one account's (small, bounded) anchor
  * rows, read-only, and never touches the vector store. Returns `undefined`
  * when no standing filter was ever anchored on this message (or it has since
@@ -331,24 +353,38 @@ const matchSemantic = async (
 	accountConfigId: string,
 	predicate: OrganizePredicate,
 	limit: number,
+	scope: OrganizeMatchScope,
 ): Promise<{ messageIds: string[]; indexEmpty: boolean }> => {
 	const semantic = deps.semantic();
-	const persisted = await findPersistedAnchor(
-		deps.filterAnchors,
-		accountConfigId,
-		predicate.anchorMessageId,
-	);
+	const persisted = scope.filterId
+		? ((await deps.filterAnchors.get(accountConfigId, scope.filterId)) ??
+			undefined)
+		: await findPersistedAnchor(
+				deps.filterAnchors,
+				accountConfigId,
+				predicate.anchorMessageId,
+			);
 	const anchor: AnchorPayload | null = persisted
 		? await anchorForWiden(deps, semantic, persisted)
 		: await semantic.buildAnchor(accountConfigId, predicate.anchorMessageId);
 	if (!anchor) return { messageIds: [], indexEmpty: true };
 	const threshold =
 		predicate.similarityThreshold ?? DEFAULT_SEMANTIC_MATCH_THRESHOLD;
-	const matches = await semantic.vectorStore.query({
-		vector: anchor.anchorEmbedding,
-		topK: limit * VECTOR_CHUNK_FACTOR,
-		filter: { accountConfigId },
-	});
+	const folders: readonly (string | undefined)[] = scope.mailboxIds ?? [
+		undefined,
+	];
+	const pages = await Promise.all(
+		folders.map((mailboxId) =>
+			semantic.vectorStore.query({
+				vector: anchor.anchorEmbedding,
+				topK: limit * VECTOR_CHUNK_FACTOR,
+				filter: mailboxId
+					? { accountConfigId, mailboxId }
+					: { accountConfigId },
+			}),
+		),
+	);
+	const matches = pages.flat();
 	if (matches.length === 0) return { messageIds: [], indexEmpty: true };
 	const bestScore = new Map<string, number>();
 	for (const match of matches) {
@@ -436,6 +472,7 @@ const matchLiteral = async (
 	accountConfigId: string,
 	predicate: OrganizePredicate,
 	limit: number,
+	scope: OrganizeMatchScope,
 ): Promise<string[]> => {
 	const clauses = predicate.literalClauses;
 	const narrowing = literalClauseTerms(clauses, predicate.matchOperator);
@@ -449,6 +486,7 @@ const matchLiteral = async (
 			...narrowing,
 			limit,
 			continuationToken,
+			mailboxIds: scope.mailboxIds,
 		});
 		for (const { messageId, message } of page.items) {
 			if (seen.has(messageId)) continue;
@@ -488,6 +526,7 @@ export const matchOrganize = async (
 	accountConfigId: string,
 	predicate: OrganizePredicate,
 	limit: number = ORGANIZE_MATCH_LIMIT,
+	scope: OrganizeMatchScope = {},
 ): Promise<OrganizeMatchResult> => {
 	const anchored = hasAnchor(predicate);
 	const clauses = predicate.literalClauses;
@@ -501,13 +540,16 @@ export const matchOrganize = async (
 	}
 
 	if (!anchored) {
-		const rejection = organizePredicateRejection(predicate);
+		const rejection = scope.filterId
+			? null
+			: organizePredicateRejection(predicate);
 		if (rejection) return { rejected: rejection };
 		const messageIds = await matchLiteral(
 			deps,
 			accountConfigId,
 			predicate,
 			limit,
+			scope,
 		);
 		return {
 			rejected: null,
@@ -523,6 +565,7 @@ export const matchOrganize = async (
 			accountConfigId,
 			predicate,
 			limit,
+			scope,
 		);
 		return {
 			rejected: null,
@@ -543,13 +586,14 @@ export const matchOrganize = async (
 				semanticIndexEmpty: false,
 			};
 		}
-		const rejection = bodyContentRejection(clauses);
+		const rejection = scope.filterId ? null : bodyContentRejection(clauses);
 		if (rejection) return { rejected: rejection };
 		const messageIds = await matchLiteral(
 			deps,
 			accountConfigId,
 			predicate,
 			limit,
+			scope,
 		);
 		return {
 			rejected: null,
@@ -591,12 +635,11 @@ const buildSemanticFromEnv = (): OrganizeSemanticDeps => {
  *
  * `From`/`Subject`/`listId` come from the row verbatim (full fidelity), so a
  * `From`, `Subject`, `FromDomain` or `ListId` clause matches here exactly as it
- * does at index time. `text` (the body) is left empty: the thread row carries
- * only a truncated `snippet`, and matching
- * a body-content clause against a preview would silently diverge from the live
- * index-time filter's full-body match. Body-content (`HasWords`) clauses are
- * rejected before this is read (see {@link bodyContentRejection}), so the
- * empty `text` is never matched against.
+ * does at index time. `text` is the row's stored body preview (`snippet`),
+ * the same text search matches free words against. An "all like these" pass
+ * refuses a body-content (`HasWords`) clause before reading it (see
+ * {@link bodyContentRejection}); a filter back-apply matches it on the
+ * preview, the mail search showed the user when the rule was made (#1354).
  */
 const listAccountFilterMessagesFromClient =
 	(client: RemitClient): OrganizeMatchDeps["listAccountFilterMessages"] =>
@@ -609,6 +652,7 @@ const listAccountFilterMessagesFromClient =
 				limit: query.limit,
 				continuationToken: query.continuationToken,
 				excludeDeleted: true,
+				mailboxIds: query.mailboxIds,
 			},
 		);
 		return {
@@ -618,7 +662,7 @@ const listAccountFilterMessagesFromClient =
 					from: row.fromEmail ?? "",
 					fromName: row.fromName ?? "",
 					subject: row.subject ?? "",
-					text: "",
+					text: row.snippet ?? "",
 					listId: row.listId ?? "",
 				},
 			})),
@@ -754,3 +798,228 @@ export const applyOrganize = async (
 	}
 	return { applied, failed };
 };
+
+const FILTER_NOT_ACTIVE_MESSAGE =
+	"This filter is turned off or has expired. Turn it on to run it over the inbox.";
+
+const FILTER_MISSING_MESSAGE =
+	"This filter was deleted before it could run over the inbox.";
+
+const rejectFilter = (
+	reason: OrganizeRejection["reason"],
+	message: string,
+): OrganizeMatchRejected => ({ rejected: { reason, message } });
+
+/**
+ * A standing filter's predicate and action, read the way index time reads
+ * them. `matchSemantic` reads the anchor vector by `filterId`; the anchor
+ * message id here only says the filter widens.
+ */
+const predicateFromFilter = (
+	filter: FilterItem,
+	anchorMessageId: string,
+): OrganizePredicate => ({
+	anchorMessageId,
+	matchOperator: filter.matchOperator,
+	literalClauses: filter.literalClauses,
+	similarityThreshold: DEFAULT_SEMANTIC_MATCH_THRESHOLD,
+	actionLabelId: filter.actionLabelId,
+	actionMailboxId: filter.actionMailboxId,
+});
+
+interface LoadedFilter {
+	rejected: null;
+	filter: FilterItem;
+	predicate: OrganizePredicate;
+	/**
+	 * Marked `hasAnchor` with its FilterAnchor row gone. Index time matches
+	 * such a filter against nothing, so the back-apply does too.
+	 */
+	matchesNothing: boolean;
+}
+
+/**
+ * Read the filter a job names: refused when it was deleted or is not Active,
+ * since index time evaluates neither.
+ */
+const loadFilter = async (
+	client: Pick<RemitClient, "filter" | "filterAnchor">,
+	accountConfigId: string,
+	filterId: string,
+): Promise<LoadedFilter | OrganizeMatchRejected> => {
+	const stored = await client.filter
+		.get(accountConfigId, filterId)
+		.catch((error: unknown) => {
+			if (error instanceof NotFoundError) return null;
+			throw error;
+		});
+	if (!stored) return rejectFilter("FilterMissing", FILTER_MISSING_MESSAGE);
+	const filter = await client.filter.refreshExpiry(stored);
+	if (filter.state !== FilterState.Active) {
+		return rejectFilter("FilterNotActive", FILTER_NOT_ACTIVE_MESSAGE);
+	}
+	if (!filter.hasAnchor) {
+		return {
+			rejected: null,
+			filter,
+			predicate: predicateFromFilter(filter, NO_ACTION),
+			matchesNothing: false,
+		};
+	}
+	const anchor = await client.filterAnchor.get(accountConfigId, filterId);
+	return {
+		rejected: null,
+		filter,
+		predicate: predicateFromFilter(
+			filter,
+			anchor?.anchorMessageId ?? NO_ACTION,
+		),
+		matchesNothing: anchor === null,
+	};
+};
+
+/** Every inbox under the config — the folders a filter back-apply runs over. */
+const inboxMailboxIds = async (
+	client: Pick<RemitClient, "account" | "mailboxSpecialUse">,
+	accountConfigId: string,
+): Promise<string[]> => {
+	const accounts =
+		await client.account.listMailSourcesByAccountConfig(accountConfigId);
+	const inboxes = await Promise.all(
+		accounts.map((account) =>
+			client.mailboxSpecialUse.findInboxMailbox(account.accountId),
+		),
+	);
+	return inboxes.flatMap((inbox) => (inbox ? [inbox.mailboxId] : []));
+};
+
+/**
+ * The message as the index-time pipeline reads it, from its thread row. The
+ * body is the stored preview, so a `HasWords` clause matches what search
+ * matched. A message deleted since its vector was written has no row.
+ */
+const filterMessageOf = async (
+	client: Pick<RemitClient, "threadMessage">,
+	accountConfigId: string,
+	messageId: string,
+): Promise<FilterMessage | null> => {
+	const row = await client.threadMessage
+		.getByMessageId(accountConfigId, messageId)
+		.catch((error: unknown) => {
+			if (error instanceof NotFoundError) return null;
+			throw error;
+		});
+	if (!row) return null;
+	return {
+		from: row.fromEmail ?? "",
+		fromName: row.fromName ?? "",
+		subject: row.subject ?? "",
+		text: row.snippet ?? "",
+		listId: row.listId ?? "",
+	};
+};
+
+export interface FilterBackApplyResult {
+	rejected: null;
+	matched: number;
+	applied: number;
+	failed: number;
+	semanticUnavailable: boolean;
+}
+
+export interface FilterBackApplyDeps {
+	client: RemitClient;
+	matchDeps: OrganizeMatchDeps;
+	moveService?: PlacementMoveService;
+	/** The embedder index time uses; read from env when absent. */
+	embedder?: MessageEmbedder;
+}
+
+/**
+ * Run one standing filter over the inbox as if each matching message had just
+ * arrived. Every message the matcher returns is a match: its label always
+ * applies, being additive. The index-time {@link FilterPipeline} only orders
+ * the exclusive move, so the move is skipped where it names another active
+ * filter. The pipeline re-scores a similarity filter against the stored
+ * preview rather than the full body, so its verdict on whether this filter
+ * matches is not asked; and an evaluate it could not finish names no other
+ * filter, so the move goes ahead rather than silently dropping out.
+ */
+export const backApplyFilter = async (
+	deps: FilterBackApplyDeps,
+	accountConfigId: string,
+	filterId: string,
+): Promise<FilterBackApplyResult | OrganizeMatchRejected> => {
+	const { client, matchDeps, moveService } = deps;
+	const loaded = await loadFilter(client, accountConfigId, filterId);
+	if (loaded.rejected) return loaded;
+	const config = buildFilterConfig(
+		{
+			filterService: client.filter,
+			filterAnchorService: client.filterAnchor,
+			messageLabelService: client.messageLabel,
+			placementMoveService: moveService,
+		},
+		deps.embedder,
+	);
+	if (!config) {
+		throw new Error(
+			"Filter back-apply needs the message-management queue to move mail",
+		);
+	}
+	const pipeline = new FilterPipeline(config, logger);
+
+	const mailboxIds = await inboxMailboxIds(client, accountConfigId);
+	const nothing: FilterBackApplyResult = {
+		rejected: null,
+		matched: 0,
+		applied: 0,
+		failed: 0,
+		semanticUnavailable: false,
+	};
+	if (loaded.matchesNothing || mailboxIds.length === 0) return nothing;
+
+	const match = await matchOrganize(
+		matchDeps,
+		accountConfigId,
+		loaded.predicate,
+		ORGANIZE_MATCH_LIMIT,
+		{ filterId, mailboxIds },
+	);
+	if (match.rejected) return match;
+
+	const { filter, predicate } = loaded;
+	const result: FilterBackApplyResult = {
+		...nothing,
+		matched: match.messageIds.length,
+		semanticUnavailable: match.semanticUnavailable,
+	};
+	for (const messageId of match.messageIds) {
+		const message = await filterMessageOf(client, accountConfigId, messageId);
+		if (!message) continue;
+		const decision = await pipeline.evaluate(
+			accountConfigId,
+			messageId,
+			message,
+		);
+		const move = (decision.move?.filterId ?? filterId) === filterId;
+		if (!move && filter.actionLabelId === NO_ACTION) continue;
+		const outcome = await applyOrganize(
+			{ client, moveService },
+			accountConfigId,
+			[messageId],
+			{
+				...predicate,
+				actionMailboxId: move ? filter.actionMailboxId : NO_ACTION,
+			},
+		);
+		result.applied += outcome.applied;
+		result.failed += outcome.failed;
+	}
+	return result;
+};
+
+/** Whether a job row runs a standing filter rather than its own snapshot. */
+export const isFilterJob = (
+	job: Pick<OrganizeJobRequestItem, "filterId">,
+): boolean => job.filterId !== NO_ACTION;