@remit/backend 0.0.87 → 0.0.88

package/package.json

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

package/src/service/organize.test.ts

@@ -101,7 +101,7 @@ const matchAccepted = async (
 	return result;
 };
 
-/** A standing filter fixture — the "other" filters the precedence check reads. */
+/** A standing filter fixture — the account's already-existing rules. */
 const filterItem = (over: Partial<FilterItem> = {}): FilterItem => ({
 	filterId: "filter-other",
 	accountConfigId: ACCOUNT_CONFIG_ID,
@@ -126,10 +126,9 @@ const filterItem = (over: Partial<FilterItem> = {}): FilterItem => ({
  * persists a standing rule.
  *
  * `activeFilters`/`filterAnchorRows`/`threadMessages` model the account's
- * *other*, already-existing standing filters and message rows the exclusive-
- * move precedence check (reader #350) reads — empty by default, so every
- * existing test (which never seeded a competing filter) is unaffected and the
- * precedence check is a same-length no-op.
+ * *other*, already-existing standing filters and message rows. A back-apply
+ * never arbitrates against them (reader #497), so `filterReads` pins that the
+ * Active filter set is not even consulted.
  */
 const trackingClient = (
 	seed: {
@@ -143,6 +142,7 @@ const trackingClient = (
 ) => {
 	const labeled: Array<{ messageId: string; labelId: string }> = [];
 	let filterWrites = 0;
+	let filterReads = 0;
 	let filterAnchorWrites = 0;
 	const anchorPuts: CreateFilterAnchorInput[] = [];
 	const activeFilters = seed.activeFilters ?? [];
@@ -190,7 +190,10 @@ const trackingClient = (
 				filterWrites += 1;
 				return {} as never;
 			},
-			listByAccountAndState: async () => activeFilters,
+			listByAccountAndState: async () => {
+				filterReads += 1;
+				return activeFilters;
+			},
 			refreshExpiry: async (filter: FilterItem) => filter,
 		},
 		filterAnchor: {
@@ -214,6 +217,7 @@ const trackingClient = (
 		client,
 		labeled,
 		filterWrites: () => filterWrites,
+		filterReads: () => filterReads,
 		filterAnchorWrites: () => filterAnchorWrites,
 		anchorPuts,
 	};
@@ -728,7 +732,7 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 
 		const tracked = trackingClient();
 		const result = await applyOrganize(
-			{ client: tracked.client, match: matchDeps(store) },
+			{ client: tracked.client },
 			ACCOUNT_CONFIG_ID,
 			applied.messageIds,
 			p,
@@ -764,7 +768,7 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 		);
 		const tracked = trackingClient();
 		const result = await applyOrganize(
-			{ client: tracked.client, match: matchDeps(store) },
+			{ client: tracked.client },
 			ACCOUNT_CONFIG_ID,
 			matched,
 			p,
@@ -794,7 +798,6 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 			{
 				client: tracked.client,
 				moveService: mover.moveService,
-				match: matchDeps(store),
 			},
 			ACCOUNT_CONFIG_ID,
 			matched,
@@ -844,7 +847,6 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 			{
 				client: tracked.client,
 				moveService: mover.moveService,
-				match: matchDeps(store),
 			},
 			ACCOUNT_CONFIG_ID,
 			matched,
@@ -880,7 +882,6 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 			{
 				client: tracked.client,
 				moveService: mover.moveService,
-				match: matchDeps(store),
 			},
 			ACCOUNT_CONFIG_ID,
 			matched,
@@ -890,7 +891,6 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 			{
 				client: tracked.client,
 				moveService: mover.moveService,
-				match: matchDeps(store),
 			},
 			ACCOUNT_CONFIG_ID,
 			matched,
@@ -912,22 +912,25 @@ describe("back-apply pipeline (matchOrganize -> applyOrganize)", () => {
 	});
 });
 
-describe("applyOrganize resolves move precedence against current Active filters (reader #350)", () => {
-	it("suppresses an out-ranked move but still applies the label", async () => {
+/**
+ * A standing filter acts when a message is first seen and when the user presses
+ * "run rules now", and holds no claim afterwards. A later apply is the newer
+ * event, so it moves the mail — and because nothing is suppressed, `applied`
+ * counts moves that happened rather than moves that were skipped (reader #497).
+ */
+describe("a user-initiated apply outranks every standing filter (reader #497)", () => {
+	it("moves a hand-picked selection a standing filter claims for a different mailbox", async () => {
 		const store = createMemoryVectorStore();
-		await store.upsert([bodyChunk("msg-1", ANCHOR_VECTOR)]);
-		// The back-applied filter — "move to mbox-old" — is out-ranked by a
-		// more-recently-changed standing filter that currently claims msg-1 for a
-		// different destination.
-		const p = predicate({
-			actionLabelId: "lbl-1",
-			actionMailboxId: "mbox-old",
-		});
-		const newerFilter = filterItem({
-			filterId: "filter-newer",
+		const picked = ["msg-1", "msg-2", "msg-3"];
+		await store.upsert(picked.map((id) => bodyChunk(id, ANCHOR_VECTOR)));
+		const p = predicate({ actionMailboxId: "mbox-projects" });
+		// The standing rule that filed all three into Archive in the first place —
+		// moving them back out is the whole point of the button.
+		const standing = filterItem({
+			filterId: "filter-github",
 			ruleChangedAt: 1_000,
 			actionChangedAt: 1_000,
-			actionMailboxId: "mbox-new",
+			actionMailboxId: "mbox-archive",
 			literalClauses: [{ field: "Subject", value: "reservation" }],
 		});
 
@@ -937,128 +940,40 @@ describe("applyOrganize resolves move precedence against current Active filters
 			p,
 		);
 		const tracked = trackingClient({
-			activeFilters: [newerFilter],
-			threadMessages: { "msg-1": { subject: "Dinner reservation" } },
+			activeFilters: [standing],
+			threadMessages: Object.fromEntries(
+				picked.map((id) => [id, { subject: "Dinner reservation" }]),
+			),
 		});
 		const mover = trackingMoveService();
 		const result = await applyOrganize(
-			{
-				client: tracked.client,
-				moveService: mover.moveService,
-				match: matchDeps(store),
-			},
+			{ client: tracked.client, moveService: mover.moveService },
 			ACCOUNT_CONFIG_ID,
 			matched,
 			p,
 		);
 
-		assert.equal(result.applied, 1, "a suppressed move is not a failure");
-		assert.equal(result.failed, 0);
-		assert.deepEqual(
-			tracked.labeled,
-			[{ messageId: "msg-1", labelId: "lbl-1" }],
-			"the additive label still applies even though the move is suppressed",
-		);
 		assert.deepEqual(
-			mover.moves,
-			[],
-			"the exclusive move is skipped in favor of the newer filter's own move",
+			mover.moves.map((move) => move.messageId).sort(),
+			picked,
+			"every hand-picked message moves",
 		);
-	});
-
-	it("moves the message when no other Active filter currently outranks it", async () => {
-		const store = createMemoryVectorStore();
-		await store.upsert([bodyChunk("msg-1", ANCHOR_VECTOR)]);
-		const p = predicate({ actionMailboxId: "mbox-target" });
-		// A different standing filter matches this message too, but agrees on the
-		// same destination — nothing to defer to.
-		const agreeingFilter = filterItem({
-			filterId: "filter-agrees",
-			ruleChangedAt: 1_000,
-			actionChangedAt: 1_000,
-			actionMailboxId: "mbox-target",
-			literalClauses: [{ field: "Subject", value: "reservation" }],
-		});
-
-		const { messageIds: matched } = await matchAccepted(
-			matchDeps(store),
-			ACCOUNT_CONFIG_ID,
-			p,
+		assert.ok(
+			mover.moves.every(
+				(move) => move.destinationMailboxId === "mbox-projects",
+			),
+			"the destination is the one the user picked, not the standing filter's",
 		);
-		const tracked = trackingClient({
-			activeFilters: [agreeingFilter],
-			threadMessages: { "msg-1": { subject: "Dinner reservation" } },
-		});
-		const mover = trackingMoveService();
-		const result = await applyOrganize(
-			{
-				client: tracked.client,
-				moveService: mover.moveService,
-				match: matchDeps(store),
-			},
-			ACCOUNT_CONFIG_ID,
-			matched,
-			p,
+		assert.equal(
+			result.applied,
+			mover.moves.length,
+			"the reported count equals the moves that actually happened",
 		);
-
-		assert.equal(result.applied, 1);
 		assert.equal(result.failed, 0);
-		assert.deepEqual(
-			mover.moves.map((m) => m.messageId),
-			["msg-1"],
-			"the move proceeds exactly as it would have before this check existed",
-		);
-	});
-
-	it("suppresses an out-ranked move by a newer *semantic* filter's persisted anchor", async () => {
-		const store = createMemoryVectorStore();
-		await store.upsert([bodyChunk("msg-1", ANCHOR_VECTOR)]);
-		const p = predicate({ actionMailboxId: "mbox-old" });
-		const newerSemanticFilter = filterItem({
-			filterId: "filter-newer-semantic",
-			ruleChangedAt: 1_000,
-			actionChangedAt: 1_000,
-			actionMailboxId: "mbox-new",
-			hasAnchor: true,
-		});
-		const persistedAnchor: FilterAnchorItem = {
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			filterId: "filter-newer-semantic",
-			anchorEmbedding: ANCHOR_VECTOR,
-			anchorEmbeddingId: CURRENT_EMBEDDING_ID,
-			anchorSourceText: ANCHOR_SOURCE_TEXT,
-			anchorMessageId: "msg-anchor-2",
-			createdAt: 0,
-			updatedAt: 0,
-		};
-
-		const { messageIds: matched } = await matchAccepted(
-			matchDeps(store),
-			ACCOUNT_CONFIG_ID,
-			p,
-		);
-		const tracked = trackingClient({
-			activeFilters: [newerSemanticFilter],
-			filterAnchorRows: [persistedAnchor],
-			threadMessages: { "msg-1": { subject: "Dinner reservation" } },
-		});
-		const mover = trackingMoveService();
-		const result = await applyOrganize(
-			{
-				client: tracked.client,
-				moveService: mover.moveService,
-				match: matchDeps(store, [], [persistedAnchor]),
-			},
-			ACCOUNT_CONFIG_ID,
-			matched,
-			p,
-		);
-
-		assert.equal(result.applied, 1);
-		assert.deepEqual(
-			mover.moves,
-			[],
-			"a newer semantic filter's own persisted anchor outranks the move",
+		assert.equal(
+			tracked.filterReads(),
+			0,
+			"the account's standing filters are not consulted at all",
 		);
 	});
 });
@@ -1067,20 +982,16 @@ describe("applyOrganize resolves move precedence against current Active filters
  * A same-dimension embedding-model swap leaves every persisted FilterAnchor
  * stamped with the old model's id and its vector in the old model's space.
  * Index-time matching repairs that lazily (RFC 039 Decision 1a); the
- * back-apply paths must do the same, or they score a current-model vector
- * against a stale-model anchor and silently disagree with the pipeline they
- * claim to mirror (reader #399).
+ * back-apply widen must do the same, or it queries with a stale-model vector
+ * and silently disagrees with the pipeline it claims to mirror (reader #399).
  */
 describe("back-apply repairs a drifted anchor the way index-time matching does (reader #399)", () => {
-	const staleAnchor = (
-		filterId: string,
-		// Written under the previous model: same dimensions, different space, so
-		// nothing but the id stamp distinguishes it from a usable anchor.
-		anchorEmbedding: number[] = ORTHOGONAL_VECTOR,
-	): FilterAnchorItem => ({
+	// Written under the previous model: same dimensions, different space, so
+	// nothing but the id stamp distinguishes it from a usable anchor.
+	const staleAnchor = (filterId: string): FilterAnchorItem => ({
 		accountConfigId: ACCOUNT_CONFIG_ID,
 		filterId,
-		anchorEmbedding,
+		anchorEmbedding: ORTHOGONAL_VECTOR,
 		anchorEmbeddingId: STALE_EMBEDDING_ID,
 		anchorSourceText: ANCHOR_SOURCE_TEXT,
 		anchorMessageId: "msg-anchor",
@@ -1143,104 +1054,6 @@ describe("back-apply repairs a drifted anchor the way index-time matching does (
 		assert.deepEqual(deps.anchorPuts[0].anchorEmbedding, ANCHOR_VECTOR);
 		assert.equal(deps.anchorPuts[0].anchorSourceText, ANCHOR_SOURCE_TEXT);
 	});
-
-	it("filterCurrentlyMatches re-embeds a drifted anchor, so the drifted filter still outranks the move", async () => {
-		const store = createMemoryVectorStore();
-		await store.upsert([bodyChunk("msg-1", ANCHOR_VECTOR)]);
-		const p = predicate({
-			actionLabelId: "lbl-1",
-			actionMailboxId: "mbox-old",
-		});
-		const newerSemanticFilter = filterItem({
-			filterId: "filter-newer-semantic",
-			ruleChangedAt: 1_000,
-			actionChangedAt: 1_000,
-			actionMailboxId: "mbox-new",
-			hasAnchor: true,
-		});
-		const drifted = staleAnchor("filter-newer-semantic");
-
-		const { messageIds: matched } = await matchAccepted(
-			matchDeps(store),
-			ACCOUNT_CONFIG_ID,
-			p,
-		);
-		const tracked = trackingClient({
-			activeFilters: [newerSemanticFilter],
-			filterAnchorRows: [drifted],
-			threadMessages: { "msg-1": { subject: "Dinner reservation" } },
-		});
-		const mover = trackingMoveService();
-		const result = await applyOrganize(
-			{
-				client: tracked.client,
-				moveService: mover.moveService,
-				match: currentModelDeps(store, [drifted]),
-			},
-			ACCOUNT_CONFIG_ID,
-			matched,
-			p,
-		);
-
-		assert.equal(result.applied, 1);
-		assert.deepEqual(
-			mover.moves,
-			[],
-			"scored against the re-embedded anchor the newer filter contests the move; against the stale one it would silently lose",
-		);
-		assert.deepEqual(
-			tracked.anchorPuts.map((put) => [put.filterId, put.anchorEmbeddingId]),
-			[["filter-newer-semantic", CURRENT_EMBEDDING_ID]],
-			"the repair is written back in place, not left for the next pass",
-		);
-	});
-
-	it("keeps a failed re-embed isolated to its own filter rather than throwing out of the arbitration", async () => {
-		const store = createMemoryVectorStore();
-		await store.upsert([bodyChunk("msg-1", ANCHOR_VECTOR)]);
-		const p = predicate({ actionMailboxId: "mbox-target" });
-		// The stale vector would score a match, so scoring against it — which is
-		// exactly what this path did before the repair existed — suppresses the
-		// move. A stamp that cannot be honoured is not a match: the filter is
-		// skipped and loudly logged, and the rest of the pass is unaffected.
-		const drifted = staleAnchor("filter-broken-anchor", ANCHOR_VECTOR);
-		const tracked = trackingClient({
-			activeFilters: [
-				filterItem({
-					filterId: "filter-broken-anchor",
-					ruleChangedAt: 1_000,
-					actionChangedAt: 1_000,
-					actionMailboxId: "mbox-elsewhere",
-					hasAnchor: true,
-				}),
-			],
-			filterAnchorRows: [drifted],
-			threadMessages: { "msg-1": { subject: "Dinner reservation" } },
-		});
-		const mover = trackingMoveService();
-
-		const result = await applyOrganize(
-			{
-				client: tracked.client,
-				moveService: mover.moveService,
-				match: currentModelDeps(store, [drifted], async (text) => {
-					if (text === ANCHOR_SOURCE_TEXT) throw new Error("embedder refused");
-					return ANCHOR_VECTOR;
-				}),
-			},
-			ACCOUNT_CONFIG_ID,
-			["msg-1"],
-			p,
-		);
-
-		assert.equal(result.applied, 1);
-		assert.equal(result.failed, 0);
-		assert.deepEqual(
-			mover.moves.map((move) => move.destinationMailboxId),
-			["mbox-target"],
-			"an un-repairable anchor skips its own filter — it neither decides the arbitration on a stale score nor aborts the pass",
-		);
-	});
 });
 
 describe("matchOrganize with ListId and FromDomain clauses", () => {
@@ -1340,7 +1153,7 @@ describe("matchOrganize with ListId and FromDomain clauses", () => {
 
 		const tracked = trackingClient();
 		const result = await applyOrganize(
-			{ client: tracked.client, match: deps },
+			{ client: tracked.client },
 			ACCOUNT_CONFIG_ID,
 			applied.messageIds,
 			p,

package/src/service/organize.ts

@@ -5,20 +5,15 @@ import type {
 	IFilterAnchorRepository,
 	OrganizeJobRequestItem,
 } from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
-import { FilterClauseField, FilterState } from "@remit/domain-enums";
+import { FilterClauseField } from "@remit/domain-enums";
 import { logger } from "@remit/logger-lambda";
 import {
-	type AnchorEmbedder,
-	buildMatchText,
-	cosineSimilarity,
 	DEFAULT_SEMANTIC_MATCH_THRESHOLD,
 	type FilterMessage,
 	literalClausesMatch,
 	NO_ACTION,
 	PlacementMoveService,
 	refreshAnchorForEmbedder,
-	selectMoveWinner,
 } from "@remit/mailbox-service";
 import {
 	type AnchorPayload,
@@ -96,12 +91,11 @@ export interface OrganizeSemanticDeps {
 	) => Promise<AnchorPayload | null>;
 	vectorStore: Pick<VectorStoreService, "query" | "getByMessage">;
 	/**
-	 * Embed one candidate message's text — used only by the cross-filter
-	 * precedence check ({@link findCurrentMoveWinner}) to compare a message
-	 * against a *different* Active filter's persisted anchor, the same
-	 * comparison `FilterPipeline.filterMatches` runs at index time. Never
-	 * called by the anchor widen itself, which only ever runs a vector-store
-	 * kNN read (see `semantic-capability.ts`).
+	 * Embed one text — the `AnchorEmbedder` half of these deps, used to
+	 * re-embed a drifted persisted anchor in place ({@link
+	 * refreshAnchorForEmbedder}). Never called by the anchor widen itself,
+	 * which only ever runs a vector-store kNN read (see
+	 * `semantic-capability.ts`).
 	 */
 	embed: (text: string) => Promise<number[]>;
 	/**
@@ -602,13 +596,6 @@ export const buildOrganizeMoveService = (
 export interface ApplyOrganizeDeps {
 	client: RemitClient;
 	moveService?: PlacementMoveService;
-	/**
-	 * The same matcher deps {@link matchOrganize} uses — reused here only for
-	 * their vector-store/embedder access, to compare a candidate message
-	 * against a *different* filter's persisted anchor when checking exclusive-
-	 * move precedence (RFC 039 Decision 2, reader #350).
-	 */
-	match: OrganizeMatchDeps;
 }
 
 export interface ApplyOrganizeResult {
@@ -616,181 +603,6 @@ export interface ApplyOrganizeResult {
 	failed: number;
 }
 
-/**
- * The vector-free literal-match projection of one already-stored message,
- * read from its ThreadMessage row — the same fields and the same fidelity
- * tradeoff {@link listAccountFilterMessagesFromClient} accepts for the
- * back-apply predicate's own literal clauses (full-fidelity From/Subject/
- * ListId, empty body text, so a `HasWords` clause on a *different* filter
- * cannot be proven to currently match here). `undefined` when the message no
- * longer exists.
- */
-const findFilterMessageForPrecedence = async (
-	client: Pick<RemitClient, "threadMessage">,
-	accountConfigId: string,
-	messageId: string,
-): Promise<FilterMessage | undefined> => {
-	const row = await client.threadMessage
-		.get(accountConfigId, messageId)
-		.catch((error: unknown) => {
-			if (error instanceof NotFoundError) return undefined;
-			throw error;
-		});
-	if (!row) return undefined;
-	return {
-		from: row.fromEmail ?? "",
-		fromName: row.fromName ?? "",
-		subject: row.subject ?? "",
-		text: "",
-		listId: row.listId ?? "",
-	};
-};
-
-/**
- * Whether one *other* Active filter with a move action currently matches this
- * message — mirrors `FilterPipeline.filterMatches` (mailbox-service
- * filters/pipeline.ts) exactly: literal clauses first, then, for a filter
- * with a semantic anchor, its own persisted `FilterAnchor` — re-embedded in
- * place through the same {@link refreshAnchorForEmbedder} the pipeline calls
- * when the model has drifted since the anchor was written — compared against
- * the candidate's embedding. A stale/incompatible anchor on the *other*
- * filter is isolated to that filter (skipped, not thrown) — the same
- * resilience `filterMatches` gives index-time matching, so one bad anchor,
- * or one anchor that cannot be re-embedded, never breaks this back-apply's
- * move.
- */
-const filterCurrentlyMatches = async (
-	filterAnchorService: Pick<IFilterAnchorRepository, "get" | "put">,
-	embedder: () => AnchorEmbedder,
-	accountConfigId: string,
-	filter: FilterItem,
-	msg: FilterMessage,
-	embed: () => Promise<number[] | null>,
-): Promise<boolean> => {
-	if (!literalClausesMatch(filter.literalClauses, filter.matchOperator, msg)) {
-		return false;
-	}
-	if (!filter.hasAnchor) {
-		return filter.literalClauses.length > 0;
-	}
-	const stored = await filterAnchorService.get(
-		accountConfigId,
-		filter.filterId,
-	);
-	if (!stored) return false;
-	const vector = await embed();
-	if (!vector) return false;
-	const repairAnchor = async (): Promise<FilterAnchorItem> =>
-		refreshAnchorForEmbedder(
-			{ anchorRepository: filterAnchorService, embedder: embedder() },
-			stored,
-		);
-	return repairAnchor()
-		.then(
-			(anchor) =>
-				cosineSimilarity(vector, anchor.anchorEmbedding) >=
-				DEFAULT_SEMANTIC_MATCH_THRESHOLD,
-		)
-		.catch((error: unknown) => {
-			logger.error(
-				{
-					alert: "filter_anchor_match_failed",
-					filterId: filter.filterId,
-					accountConfigId,
-					errorName: (error as { name?: string })?.name,
-					error: inspect(error),
-				},
-				"Filter anchor comparison failed during back-apply precedence; skipping this filter, the rest still arbitrate (bad/stale anchor vector or a failed repair, non-fatal)",
-			);
-			return false;
-		});
-};
-
-/**
- * The filter that currently wins this message's exclusive move, evaluated
- * fresh against every Active filter with a move action — the same
- * cross-filter arbitration index-time matching runs
- * (`FilterPipeline`/`selectMoveWinner`), never the back-apply job's own
- * snapshotted predicate (RFC 039 Decision 2, reader #350). This is what lets
- * back-apply defer to a filter created or edited *after* the job was
- * requested. `movers` is fetched once per {@link applyOrganize} call, not
- * once per message — a back-apply pass runs in one short burst, so the
- * account's Active filter set does not need re-reading per message.
- *
- * Returns `undefined` — meaning "nothing else contests this move" — whenever
- * there are no other Active mover filters, or the message's own projection
- * cannot be built (deleted between match and apply). Both are the common
- * case and the safe default: proceed with the requested move exactly as
- * before this check existed.
- */
-const findCurrentMoveWinner = async (
-	deps: {
-		client: Pick<RemitClient, "threadMessage" | "filterAnchor">;
-		match: OrganizeMatchDeps;
-	},
-	movers: readonly FilterItem[],
-	accountConfigId: string,
-	messageId: string,
-): Promise<FilterItem | undefined> => {
-	if (movers.length === 0) return undefined;
-	const msg = await findFilterMessageForPrecedence(
-		deps.client,
-		accountConfigId,
-		messageId,
-	);
-	if (!msg) return undefined;
-
-	let messageEmbedding: number[] | null | undefined;
-	const embed = async (): Promise<number[] | null> => {
-		if (messageEmbedding !== undefined) return messageEmbedding;
-		try {
-			messageEmbedding = await deps.match.semantic().embed(buildMatchText(msg));
-		} catch (error) {
-			if (!noteSemanticCapabilityAbsence(error)) throw error;
-			messageEmbedding = null;
-		}
-		return messageEmbedding;
-	};
-
-	const matched: FilterItem[] = [];
-	for (const filter of movers) {
-		const isMatch = await filterCurrentlyMatches(
-			deps.client.filterAnchor,
-			() => deps.match.semantic(),
-			accountConfigId,
-			filter,
-			msg,
-			embed,
-		);
-		if (isMatch) matched.push(filter);
-	}
-	return selectMoveWinner(matched);
-};
-
-/**
- * Every currently-Active filter with a move action, its lazy Temporary-expiry
- * check already applied — the fixed candidate set {@link findCurrentMoveWinner}
- * arbitrates against for every message in this pass. Empty (and read exactly
- * once) when no move action was requested, so a label-only back-apply never
- * pays for this at all.
- */
-const listCurrentMovers = async (
-	client: Pick<RemitClient, "filter">,
-	accountConfigId: string,
-): Promise<FilterItem[]> => {
-	const active = await client.filter.listByAccountAndState(
-		accountConfigId,
-		FilterState.Active,
-	);
-	const movers: FilterItem[] = [];
-	for (const filter of active) {
-		if (filter.actionMailboxId === NO_ACTION) continue;
-		const usable = await client.filter.refreshExpiry(filter);
-		if (usable.state === FilterState.Active) movers.push(usable);
-	}
-	return movers;
-};
-
 /**
  * Apply the back-apply action to every matched message, reusing the index-time
  * apply plumbing: an idempotent MessageLabel upsert (additive) with
@@ -799,12 +611,13 @@ const listCurrentMovers = async (
  * folder move (exclusive). One poisoned message never fails the batch; it is
  * counted as failed and the pass continues.
  *
- * Before an exclusive move, resolves whether a *different* Active filter
- * currently wins that message (RFC 039 Decision 2, reader #350): if so, the
- * move is skipped for that message — the label action above, if requested,
- * still applies, since labels are additive and always safe. A message with no
- * contesting filter, or whose own back-applied filter is still the current
- * winner, moves exactly as before this check existed.
+ * Every requested move happens. A standing filter acts at exactly two moments —
+ * when a message is first seen, and when the user presses "run rules now" — and
+ * holds no claim on that message afterwards, so it never arbitrates against a
+ * later user-initiated apply (reader #497). Cross-filter precedence stays where
+ * two filters collide over the same message at the same trigger
+ * (`FilterPipeline`/`selectMoveWinner`), and `applied` therefore counts moves
+ * that actually happened.
  */
 export const applyOrganize = async (
 	deps: ApplyOrganizeDeps,
@@ -812,16 +625,12 @@ export const applyOrganize = async (
 	messageIds: readonly string[],
 	predicate: OrganizePredicate,
 ): Promise<ApplyOrganizeResult> => {
-	const { client, moveService, match } = deps;
+	const { client, moveService } = deps;
 	const applyLabel =
 		predicate.actionLabelId !== NO_ACTION && predicate.actionLabelId !== "";
 	const applyMove =
 		predicate.actionMailboxId !== NO_ACTION && predicate.actionMailboxId !== "";
 
-	const movers = applyMove
-		? await listCurrentMovers(client, accountConfigId)
-		: [];
-
 	const applyToMessage = async (messageId: string): Promise<void> => {
 		if (applyLabel) {
 			await client.messageLabel.apply({
@@ -831,18 +640,6 @@ export const applyOrganize = async (
 			});
 		}
 		if (applyMove) {
-			const winner = await findCurrentMoveWinner(
-				{ client, match },
-				movers,
-				accountConfigId,
-				messageId,
-			);
-			if (winner && winner.actionMailboxId !== predicate.actionMailboxId) {
-				// A more-recently-changed filter currently claims this message's
-				// move (RFC 034 Decision 3.2) — defer to it. The label above, if
-				// requested, has already applied; only the move is suppressed.
-				return;
-			}
 			if (!moveService) {
 				// An exclusive move was requested but this caller wired no move
 				// service. Never silently pretend it applied — surface it as a