@remit/web-client 0.0.277 → 0.0.279

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.277",
+  "version": "0.0.279",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/IntelligencePane.tsx

@@ -159,16 +159,25 @@ function IntelligenceSkeleton() {
 /**
  * Reclassify picker: a small modal listing the category-override options. On
  * selection it PATCHes `AddressFlags.category` for the sender.
+ *
+ * A sender that already carries an override also gets the way back out. The
+ * override is an enum with no false-equivalent member, so removal is not a
+ * value to send — it is `clearFlags: ["category"]`, the contract's removal
+ * form for every flag (#615).
  */
 function ReclassifyDialog({
 	isOpen,
 	current,
+	hasOverride,
 	onSelect,
+	onClear,
 	onCancel,
 }: {
 	isOpen: boolean;
 	current: string;
+	hasOverride: boolean;
 	onSelect: (category: CategoryOverride) => void;
+	onClear: () => void;
 	onCancel: () => void;
 }) {
 	const dialogRef = useRef<HTMLDivElement>(null);
@@ -210,6 +219,15 @@ function ReclassifyDialog({
 							)}
 						</button>
 					))}
+					{hasOverride && (
+						<button
+							type="button"
+							onClick={onClear}
+							className="mt-1 flex min-h-11 items-center rounded border-t border-line px-3 text-left text-sm text-fg transition-colors hover:bg-surface-raised"
+						>
+							Remove override — classify automatically again
+						</button>
+					)}
 				</div>
 				<div className="mt-6 flex justify-end">
 					<button
@@ -247,6 +265,7 @@ function WiredPanel({
 }: WiredPanelProps) {
 	const {
 		data,
+		address,
 		addressId,
 		isSimilarLoading,
 		similarError,
@@ -256,7 +275,7 @@ function WiredPanel({
 	const [reclassifyOpen, setReclassifyOpen] = useState(false);
 	const senderEmail = thread.fromEmail ?? undefined;
 
-	const { updateFlags } = useUpdateAddressFlags({
+	const { updateFlags, clearFlags } = useUpdateAddressFlags({
 		addressId,
 		senderEmail,
 	});
@@ -315,6 +334,11 @@ function WiredPanel({
 		[updateFlags],
 	);
 
+	const handleReclassifyClear = useCallback(() => {
+		setReclassifyOpen(false);
+		clearFlags(["category"]);
+	}, [clearFlags]);
+
 	// Every per-sender flag toggle PATCHes the sender's address row, so none of
 	// them can be serviced until that row resolves. Leave them unwired until it
 	// does: the panel renders an unwired quick action as disabled, so the flow is
@@ -383,7 +407,9 @@ function WiredPanel({
 			<ReclassifyDialog
 				isOpen={reclassifyOpen}
 				current={data.category.value}
+				hasOverride={address?.flags?.category?.value != null}
 				onSelect={handleReclassifySelect}
+				onClear={handleReclassifyClear}
 				onCancel={() => setReclassifyOpen(false)}
 			/>
 		</>

package/src/components/mail/SelectionWizardHost.tsx

@@ -4,7 +4,6 @@ import {
 	type ClauseDraft,
 	type ClauseEditState,
 	derivePropertyClauses,
-	deriveSenderClauses,
 	dominantSender,
 	type FolderTreeNode,
 	type MatchCount,
@@ -403,6 +402,7 @@ function SelectionWizardSession({
 		escalated ? undefined : accountId,
 		anchorMessageId,
 		senders,
+		subjects,
 	);
 	const { preview: probeWiden } = widen;
 	// The similar door has to know before it is pressed whether it can run, so
@@ -581,20 +581,22 @@ function SelectionWizardSession({
 		[anchorMessageId, selection.length, seedPropertyClauses],
 	);
 
-	// The dimmed similar door, pressed. The senders the widen would have fallen
-	// back to are filled in on the property step instead of standing in for the
-	// semantic match without saying so (#477 3.6).
+	// The dimmed similar door, pressed. What the widen would have fallen back to
+	// is filled in on the property step instead of standing in for the semantic
+	// match without saying so (#477 3.6) — the same agreement the property step
+	// itself seeds from (#458), not senders alone: a selection with nothing in
+	// common on sender still shares a subject worth matching on.
 	const takeSemanticFallback = useCallback(() => {
 		setSemanticFallbackTaken(true);
 		setDoor("properties");
 		setDraft((held) => ({
 			...held,
 			widen: undefined,
-			clauses: withIds(deriveSenderClauses(senders), "sender"),
+			clauses: seedPropertyClauses(),
 			matchOperator: "any",
 		}));
 		goToStep("properties");
-	}, [senders, goToStep]);
+	}, [seedPropertyClauses, goToStep]);
 
 	// The probe lands after the door is on screen, so it can report the widen
 	// unavailable while the user is already holding it. The fallback is taken then

package/src/components/mail/reclassify-remove-override.render.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Removing a sender's category override (#615).
+ *
+ * A sender flag is removed by naming its key in `clearFlags`. `category` is the
+ * flag that has no other way out: its value is a `MessageCategory` enum with no
+ * false-equivalent member, so the `{ value: false }` form the boolean flags use
+ * cannot express "no override", and the `null` form the schema documents is
+ * rejected by the request validator. Before this the reclassify picker was
+ * one-way — a reader could set an override and never take it back.
+ *
+ * Drives the real chain: the real `IntelligencePane`, the real
+ * `useUpdateAddressFlags` mutation, and a fetch mock that answers the way the
+ * server does. Both halves are asserted — the body that goes on the wire, and
+ * that the override is gone from what the panel renders.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { RemitImapAddressResponse } from "@remit/api-http-client/types.gen.ts";
+import { createElement } from "react";
+import { createDomHarness, type DomHarness } from "@/test-support/dom";
+import {
+	makeAccount,
+	makeConfig,
+	makeThreadMessage,
+} from "@/test-support/fixtures";
+import { type HttpMock, mockFetch } from "@/test-support/http";
+import { IntelligencePane } from "./IntelligencePane";
+
+const thread = makeThreadMessage({ messageId: "msg-1", category: "personal" });
+
+const addressWith = (
+	flags: RemitImapAddressResponse["flags"],
+): RemitImapAddressResponse => ({
+	addressId: "addr-1",
+	accountConfigId: "cfg-1",
+	displayName: "Alice",
+	localPart: "alice",
+	domain: "example.com",
+	normalizedEmail: "alice@example.com",
+	flags,
+	inboundCount: 6,
+	outboundCount: 1,
+	replyCount: 2,
+	lastInboundAt: 1_000,
+	lastReplyAt: 900,
+	createdAt: 0,
+	updatedAt: 0,
+});
+
+let harness: DomHarness | undefined;
+let http: HttpMock;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http.restore();
+});
+
+describe("the reclassify picker on a sender that already carries an override", () => {
+	it("removes the override with clearFlags, and the panel stops claiming one", async () => {
+		let stored: RemitImapAddressResponse = addressWith({
+			category: { value: "newsletter", setAt: 10 },
+		});
+
+		http = mockFetch((call) => {
+			if (call.path.endsWith("/config")) {
+				return makeConfig([makeAccount({ accountId: "acc-1" })], {
+					semanticSearchEnabled: false,
+				});
+			}
+			if (call.path.endsWith("/addresses/search")) {
+				return { items: [stored] };
+			}
+			if (call.method === "PATCH" && call.path.endsWith("/addresses/addr-1")) {
+				stored = addressWith({});
+				return stored;
+			}
+			return { items: [] };
+		});
+
+		harness = createDomHarness();
+		harness.renderApp(
+			createElement(IntelligencePane, { thread, onClose: () => {} }),
+		);
+
+		await harness.waitFor(
+			() => harness?.text().includes("your override") === true,
+			"the panel never showed the sender's category override",
+		);
+
+		harness.click(harness.byText("button", "reclassify"));
+		harness.click(
+			harness.byText(
+				"button",
+				"Remove override — classify automatically again",
+			),
+		);
+
+		await harness.waitFor(
+			() => http.to("/addresses/addr-1").length === 1,
+			"the remove control sent no request",
+		);
+
+		assert.deepEqual(http.to("/addresses/addr-1")[0].body, {
+			clearFlags: ["category"],
+		});
+
+		await harness.waitFor(
+			() => harness?.text().includes("your override") === false,
+			"the override survived its own removal",
+		);
+	});
+
+	it("offers no removal on a sender that carries no override", async () => {
+		http = mockFetch((call) => {
+			if (call.path.endsWith("/config")) {
+				return makeConfig([makeAccount({ accountId: "acc-1" })], {
+					semanticSearchEnabled: false,
+				});
+			}
+			if (call.path.endsWith("/addresses/search")) {
+				return { items: [addressWith({})] };
+			}
+			return { items: [] };
+		});
+
+		harness = createDomHarness();
+		harness.renderApp(
+			createElement(IntelligencePane, { thread, onClose: () => {} }),
+		);
+
+		await harness.waitFor(
+			() => harness?.text().includes("reclassify") === true,
+			"the panel never rendered the category section",
+		);
+
+		harness.click(harness.byText("button", "reclassify"));
+
+		assert.equal(harness.text().includes("Remove override"), false);
+	});
+});

package/src/hooks/useOrganizeWiden.test.ts

@@ -2,9 +2,10 @@
  * The widen step's two-phase preview. On a semantic-capable deployment it runs
  * the anchor preview once and stops. On a deployment that reports
  * `semanticUnavailable` (no vector pipeline — semantic-capability.ts) it
- * re-previews with sender-derived literal clauses — one `From` clause per
- * distinct sender, combined with `Or`, no anchor — and reports the literal match
- * count, so every commit scope acts on the sender-matched set.
+ * re-previews with what the whole selection agrees on (#458) — one `From` or
+ * `FromDomain` clause when senders agree, the shared subject when they don't,
+ * combined with `Or`, no anchor — and reports the literal match count, so
+ * every commit scope acts on the same set the fallback derived.
  */
 
 import assert from "node:assert/strict";
@@ -29,12 +30,16 @@ type Responder = Parameters<typeof mockFetch>[0];
 
 const PREVIEW_PATH = "/organize/preview";
 
-const mount = (senders: string[], responder: Responder) => {
+const mount = (
+	senders: string[],
+	responder: Responder,
+	subjects: string[] = [],
+) => {
 	http = mockFetch(responder);
 	harness = createDomHarness();
 	const holder: { current: Widen | undefined } = { current: undefined };
 	function Probe() {
-		const widen = useOrganizeWiden("acc-1", "msg-1", senders);
+		const widen = useOrganizeWiden("acc-1", "msg-1", senders, subjects);
 		holder.current = widen;
 		const { preview } = widen;
 		useEffect(() => {
@@ -130,6 +135,39 @@ describe("useOrganizeWiden — no vector pipeline, senders present", () => {
 	});
 });
 
+describe("useOrganizeWiden — no vector pipeline, mixed senders sharing a subject", () => {
+	it("re-previews with the shared subject rather than one From clause per sender (#458)", async () => {
+		const holder = mount(
+			["billing@acme.test", "accounts@globex.test"],
+			(call) =>
+				call.body?.anchorMessageId
+					? { matchedCount: 0, messageIds: [], semanticUnavailable: true }
+					: {
+							matchedCount: 64,
+							messageIds: ["m"],
+							semanticUnavailable: false,
+						},
+			["Invoice 1841", "Invoice 1902"],
+		);
+		await settle(2);
+
+		const calls = http?.to(PREVIEW_PATH) ?? [];
+		assert.equal(calls.length, 2);
+		const second = calls[1];
+		assert.equal(second.body?.anchorMessageId, undefined);
+		assert.equal(second.body?.matchOperator, "Or");
+		assert.deepEqual(second.body?.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+
+		const widen = holder.current;
+		assert.deepEqual(widen?.matchPredicate, {
+			matchOperator: "Or",
+			literalClauses: [{ field: "Subject", value: "Invoice" }],
+		});
+	});
+});
+
 describe("useOrganizeWiden — no vector pipeline, no senders", () => {
 	it("does not re-preview and stays capability-absent with the anchor predicate", async () => {
 		const holder = mount([], () => ({
@@ -148,4 +186,32 @@ describe("useOrganizeWiden — no vector pipeline, no senders", () => {
 		assert.deepEqual(widen?.senders, []);
 		assert.equal(widen?.matchPredicate.anchorMessageId, "msg-1");
 	});
+
+	it("still re-previews on a shared subject alone (#458)", async () => {
+		const holder = mount(
+			[],
+			(call) =>
+				call.body?.anchorMessageId
+					? { matchedCount: 0, messageIds: [], semanticUnavailable: true }
+					: {
+							matchedCount: 12,
+							messageIds: ["m"],
+							semanticUnavailable: false,
+						},
+			["Invoice 1841", "Invoice 1902"],
+		);
+		await settle(2);
+
+		const calls = http?.to(PREVIEW_PATH) ?? [];
+		assert.equal(calls.length, 2);
+		const second = calls[1];
+		assert.equal(second.body?.anchorMessageId, undefined);
+		assert.deepEqual(second.body?.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+
+		const widen = holder.current;
+		assert.equal(widen?.semanticUnavailable, true);
+		assert.equal(widen?.senderFallback, true);
+	});
 });

package/src/hooks/useOrganizeWiden.ts

@@ -1,5 +1,5 @@
 import { organizeOperationsPreviewOrganizeMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { deriveSenderClauses, distinctSenders } from "@remit/ui";
+import { derivePropertyClauses, distinctSenders } from "@remit/ui";
 import { useMutation } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { buildOrganizeInput } from "@/lib/organize/organize-model";
@@ -9,16 +9,17 @@ import {
 } from "@/lib/organize/sender-fallback";
 
 /**
- * "Select similar messages" (the widen step) with a sender-derived fallback for
- * deployments without the vector pipeline.
+ * "Select similar messages" (the widen step) with a selection-agreement
+ * fallback for deployments without the vector pipeline.
  *
  * The first preview runs the semantic anchor (POST /organize/preview). When the
  * server reports `semanticUnavailable` — no vector pipeline on this deployment
  * (semantic-capability.ts) — the widen re-previews with the literal vocabulary
- * that matches vector-free: one `From` clause per distinct sender in the
- * selection, combined with `Or`, no anchor. The counts shown, the one-time
- * back-apply, and any standing filter then all carry that same literal
- * predicate, so the previewed set equals the set every commit scope acts on.
+ * that matches vector-free: what the whole selection agrees on (#458) — one
+ * sender/domain clause, or the subject the selection shares when senders don't
+ * — combined with `Or`, no anchor. The counts shown, the one-time back-apply,
+ * and any standing filter then all carry that same literal predicate, so the
+ * previewed set equals the set every commit scope acts on.
  *
  * A semantic-capable deployment never fires the second preview and keeps exactly
  * the anchor behaviour.
@@ -27,12 +28,17 @@ export const useOrganizeWiden = (
 	accountId: string | undefined,
 	anchorMessageId: string | undefined,
 	senders: readonly string[],
+	subjects: readonly string[],
 ) => {
 	const mutation = useMutation(organizeOperationsPreviewOrganizeMutation());
 	const { mutate, reset: mutationReset } = mutation;
 	const [fellBack, setFellBack] = useState(false);
 
 	const distinct = useMemo(() => distinctSenders(senders), [senders]);
+	const agreementClauses = useMemo(
+		() => derivePropertyClauses(distinct, subjects),
+		[distinct, subjects],
+	);
 
 	const preview = useCallback(() => {
 		if (!accountId || !anchorMessageId) return;
@@ -53,21 +59,24 @@ export const useOrganizeWiden = (
 	}, [mutationReset]);
 
 	const data = mutation.data;
-	// The first preview came back capability-absent and there are senders to
-	// match on: re-preview with the literal clauses before showing any count, so
-	// the count the user sees is the sender-match count, never a flash of the
-	// empty semantic result.
+	// The first preview came back capability-absent and the selection agrees on
+	// something to match on — a sender, a domain, or just a shared subject, not
+	// senders alone (#458): re-preview with the literal clauses before showing
+	// any count, so the count the user sees is the agreement's match count,
+	// never a flash of the empty semantic result.
 	const willFallBack =
-		data?.semanticUnavailable === true && !fellBack && distinct.length > 0;
+		data?.semanticUnavailable === true &&
+		!fellBack &&
+		agreementClauses.length > 0;
 
 	useEffect(() => {
 		if (!willFallBack || !accountId) return;
 		setFellBack(true);
 		mutate({
 			path: { accountId },
-			body: buildOrganizeInput(buildSenderFallbackDraft(distinct)),
+			body: buildOrganizeInput(buildSenderFallbackDraft(distinct, subjects)),
 		});
-	}, [willFallBack, accountId, distinct, mutate]);
+	}, [willFallBack, accountId, distinct, subjects, mutate]);
 
 	// The literal re-preview has no anchor, so its response reports
 	// `semanticUnavailable: false`; `fellBack` is what remembers the capability
@@ -76,7 +85,7 @@ export const useOrganizeWiden = (
 	const isPending = mutation.isPending || willFallBack;
 
 	const matchPredicate: OrganizeMatchPredicate = fellBack
-		? { matchOperator: "Or", literalClauses: deriveSenderClauses(distinct) }
+		? { matchOperator: "Or", literalClauses: agreementClauses }
 		: {
 				...(anchorMessageId ? { anchorMessageId } : {}),
 				matchOperator: "And",

package/src/hooks/useUpdateAddressFlags.ts

@@ -4,6 +4,7 @@ import {
 } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import type {
 	AddressOperationsSearchAddressesResponse,
+	RemitImapAddressFlagKey,
 	RemitImapAddressFlags,
 	RemitImapUpdateAddressFlagsInput,
 } from "@remit/api-http-client/types.gen.ts";
@@ -25,15 +26,17 @@ interface MutationContext {
 }
 
 /**
- * Apply a flag-update patch onto an existing AddressFlags object. Each key in
- * `patch` is a flag update object (set) or `null` (remove). Mirrors the
- * server-side merge semantics so the optimistic cache matches what the API
- * returns. Typed loosely (the per-key flag value types differ — boolean for
- * most, a category enum for `category`) and re-narrowed at the return.
+ * Apply a flag update onto an existing AddressFlags object. Each key in
+ * `patch` is a flag update object; each key in `clear` is removed outright,
+ * after the patch, matching the server's ordering. Mirrors the server-side
+ * merge semantics so the optimistic cache matches what the API returns. Typed
+ * loosely (the per-key flag value types differ — boolean for most, a category
+ * enum for `category`) and re-narrowed at the return.
  */
 function applyFlagPatch(
 	current: RemitImapAddressFlags | undefined,
 	patch: RemitImapUpdateAddressFlagsInput,
+	clear: readonly RemitImapAddressFlagKey[] = [],
 ): RemitImapAddressFlags {
 	const next: Record<string, unknown> = { ...(current ?? {}) };
 	for (const [key, update] of Object.entries(patch)) {
@@ -45,6 +48,9 @@ function applyFlagPatch(
 			next[key] = { ...update, setAt: update.setAt ?? Date.now() };
 		}
 	}
+	for (const key of clear) {
+		delete next[key];
+	}
 	return next as RemitImapAddressFlags;
 }
 
@@ -69,6 +75,7 @@ export function useUpdateAddressFlags({
 		...addressDetailOperationsUpdateAddressMutation(),
 		onMutate: async (vars): Promise<MutationContext> => {
 			const patch = vars.body.flags ?? {};
+			const clear = vars.body.clearFlags ?? [];
 			await queryClient.cancelQueries({ queryKey: addressCacheKey });
 
 			const previous =
@@ -84,7 +91,7 @@ export function useUpdateAddressFlags({
 						...old,
 						items: old.items.map((addr) =>
 							addr.addressId === vars.path.addressId
-								? { ...addr, flags: applyFlagPatch(addr.flags, patch) }
+								? { ...addr, flags: applyFlagPatch(addr.flags, patch, clear) }
 								: addr,
 						),
 					};
@@ -108,8 +115,11 @@ export function useUpdateAddressFlags({
 		},
 	});
 
-	const updateFlags = useCallback(
-		(flags: RemitImapUpdateAddressFlagsInput) => {
+	const submit = useCallback(
+		(body: {
+			flags?: RemitImapUpdateAddressFlagsInput;
+			clearFlags?: RemitImapAddressFlagKey[];
+		}) => {
 			if (!addressId) {
 				reportFatalError(
 					new Error(
@@ -118,10 +128,25 @@ export function useUpdateAddressFlags({
 				);
 				return;
 			}
-			mutate({ path: { addressId }, body: { flags } });
+			mutate({ path: { addressId }, body });
 		},
 		[addressId, mutate, senderEmail],
 	);
 
-	return { updateFlags, isPending };
+	const updateFlags = useCallback(
+		(flags: RemitImapUpdateAddressFlagsInput) => submit({ flags }),
+		[submit],
+	);
+
+	/**
+	 * Remove flags outright. This is the removal form for every flag whatever
+	 * its value type: `category` holds an enum with no false-equivalent member,
+	 * so `{ value: false }` cannot express "no override" for it.
+	 */
+	const clearFlags = useCallback(
+		(keys: RemitImapAddressFlagKey[]) => submit({ clearFlags: keys }),
+		[submit],
+	);
+
+	return { updateFlags, clearFlags, isPending };
 }

package/src/lib/organize/sender-fallback.test.ts

@@ -4,7 +4,10 @@ import { buildSenderFallbackDraft } from "./sender-fallback";
 
 describe("buildSenderFallbackDraft", () => {
 	it("combines the sender clauses with Or and carries no anchor", () => {
-		const draft = buildSenderFallbackDraft(["npm@github.com", "a@x.com"]);
+		const draft = buildSenderFallbackDraft(
+			["npm@github.com", "a@x.com"],
+			["Deploy failed", "Standup notes"],
+		);
 		assert.equal(draft.matchOperator, "Or");
 		assert.equal(draft.anchorMessageId, undefined);
 		assert.deepEqual(draft.literalClauses, [
@@ -14,10 +17,36 @@ describe("buildSenderFallbackDraft", () => {
 	});
 
 	it("carries a single FromDomain clause when the senders share a domain", () => {
-		const draft = buildSenderFallbackDraft(["npm@github.com", "ci@github.com"]);
+		const draft = buildSenderFallbackDraft(
+			["npm@github.com", "ci@github.com"],
+			["Deploy failed", "Standup notes"],
+		);
 		assert.equal(draft.matchOperator, "Or");
 		assert.deepEqual(draft.literalClauses, [
 			{ field: "FromDomain", value: "github.com" },
 		]);
 	});
+
+	it("falls back to a shared subject when mixed senders share no domain (#458)", () => {
+		const draft = buildSenderFallbackDraft(
+			["billing@acme.test", "accounts@globex.test"],
+			["Invoice 1841", "Invoice 1902"],
+		);
+		assert.equal(draft.matchOperator, "Or");
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "Subject", value: "Invoice" },
+		]);
+	});
+
+	it("offers one sender chip each when mixed senders share no subject either", () => {
+		const draft = buildSenderFallbackDraft(
+			["billing@acme.test", "accounts@globex.test"],
+			["Invoice 1841", "Standup notes"],
+		);
+		assert.equal(draft.matchOperator, "Or");
+		assert.deepEqual(draft.literalClauses, [
+			{ field: "From", value: "billing@acme.test" },
+			{ field: "From", value: "accounts@globex.test" },
+		]);
+	});
 });

package/src/lib/organize/sender-fallback.ts

@@ -1,26 +1,30 @@
 import type { RemitImapOrganizeInput } from "@remit/api-http-client/types.gen.ts";
-import { deriveSenderClauses } from "@remit/ui";
+import { derivePropertyClauses } from "@remit/ui";
 import type { OrganizeDraft } from "./organize-model";
 
 /**
  * The widen fallback for a deployment that ships no vector pipeline (self-host
  * sqlite — semantic-capability.ts). The semantic anchor matches nothing there,
  * so a widen degrades to the literal vocabulary RFC 031 already matches
- * vector-free: the sender clauses `@remit/ui` derives, combined with `Or`, no
- * anchor. The same predicate matches at index time (RFC 034), so a standing
- * filter built from it keeps working on future mail.
+ * vector-free: what the whole selection agrees on, combined with `Or`, no
+ * anchor (#458) — the same evidence order the properties door prefills from,
+ * so a selection with nothing in common on sender still falls back to a
+ * subject it shares rather than one `From` chip per message. The same
+ * predicate matches at index time (RFC 034), so a standing filter built from
+ * it keeps working on future mail.
  */
 
 /**
- * The literal predicate that stands in for the semantic anchor: the sender
- * clauses combined with `Or` and no anchor. The preview, the one-time
- * back-apply, and the standing filter all carry exactly this.
+ * The literal predicate that stands in for the semantic anchor: the clauses
+ * the selection agrees on, combined with `Or` and no anchor. The preview, the
+ * one-time back-apply, and the standing filter all carry exactly this.
  */
 export const buildSenderFallbackDraft = (
 	senders: readonly string[],
+	subjects: readonly string[],
 ): OrganizeDraft => ({
 	matchOperator: "Or",
-	literalClauses: deriveSenderClauses(senders),
+	literalClauses: derivePropertyClauses(senders, subjects),
 });
 
 /**