@remit/web-client 0.0.278 → 0.0.279

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.278",
+  "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/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/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/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),
 });
 
 /**