@remit/mailbox-service 0.0.25 → 0.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/body-sync-backfill.test.ts

@@ -72,15 +72,17 @@ const buildHarness = (
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
-		getByMessageId: async () => ({
-			threadMessageId: "tm-1",
-			sentDate: 1,
-			mailboxId: "mb-1",
-			isRead: false,
-			isDeleted: false,
-			hasStars: false,
-			hasAttachment: false,
-		}),
+		findAllByMessageId: async () => [
+			{
+				threadMessageId: "tm-1",
+				sentDate: 1,
+				mailboxId: "mb-1",
+				isRead: false,
+				isDeleted: false,
+				hasStars: false,
+				hasAttachment: false,
+			},
+		],
 		update: async (
 			_accountConfigId: string,
 			_threadMessageId: string,

package/src/body-sync-category-denormalize.test.ts

@@ -0,0 +1,341 @@
+/**
+ * `thread_message.category` is the copy the list read path is about to filter
+ * on, and its write-path defects only appear under conditions a happy-path test
+ * never creates (issue #320).
+ *
+ * 1. The retro classification path wrote the Message before the ThreadMessage
+ *    while its skip guard keyed off `message.category`. A failure between the
+ *    two left the guard satisfied and the denormalized row stranded at
+ *    `uncategorized` forever, because the requeued retry returned early.
+ * 2. `denormalizeCategory` resolved one arbitrary row per message through an
+ *    unordered `.limit(1)`. More than one row per messageId is schema-legal —
+ *    reachable through thread-root drift, not through a second mailbox, whose ids
+ *    collapse to one row — and every row a message has must end up correct.
+ * 3. It also wrote only `category` on the retro path, so a copied message, which
+ *    reaches no other denormalizing path, never got a `listId` at all.
+ *
+ * None of these show up on a single row in a single successful pass.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAddressRepository,
+	IEnvelopeRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+	MessageItem,
+	ThreadMessageItem,
+	UpdateMessageInput,
+	UpdateThreadMessageInput,
+} from "@remit/data-ports";
+import { MessageCategory } from "@remit/domain-enums";
+import type { StorageService } from "@remit/storage-service";
+import { BodySyncService } from "./body-sync.js";
+import type { IImapConnection } from "./types.js";
+
+const LINKEDIN_EML = Buffer.from(
+	[
+		"From: LinkedIn <messages-noreply@linkedin.com>",
+		"To: me@example.com",
+		"Subject: You have a new invitation",
+		"List-Id: LinkedIn Invitations <invitations.linkedin.com>",
+		"List-Unsubscribe: <https://www.linkedin.com/e/unsub>",
+		"Content-Type: text/plain",
+		"",
+		"invitation body text",
+	].join("\r\n"),
+);
+
+type Row = Pick<
+	ThreadMessageItem,
+	| "threadMessageId"
+	| "messageId"
+	| "accountConfigId"
+	| "mailboxId"
+	| "sentDate"
+	| "isRead"
+	| "isDeleted"
+	| "hasStars"
+	| "hasAttachment"
+	| "category"
+> &
+	Partial<Pick<ThreadMessageItem, "snippet" | "listId">>;
+
+interface ThreadUpdate {
+	threadMessageId: string;
+	input: UpdateThreadMessageInput;
+	composites: Record<string, unknown> | undefined;
+}
+
+interface Harness {
+	service: BodySyncService;
+	message: MessageItem;
+	rows: Row[];
+	messageUpdates: Array<{ messageId: string; input: UpdateMessageInput }>;
+	threadUpdates: ThreadUpdate[];
+	writeOrder: string[];
+}
+
+const buildRow = (
+	overrides: Partial<Row> & Pick<Row, "threadMessageId">,
+): Row =>
+	({
+		messageId: "m-1",
+		accountConfigId: "cfg-1",
+		mailboxId: "mb-inbox",
+		sentDate: 1,
+		isRead: false,
+		isDeleted: false,
+		hasStars: false,
+		hasAttachment: false,
+		category: MessageCategory.uncategorized,
+		...overrides,
+	}) as Row;
+
+/**
+ * The Message and ThreadMessage fixtures are mutated by their writes, so the
+ * skip guard sees the state a requeued delivery would. A harness that only
+ * records the write cannot show a stranded row: the strand is the guard reading
+ * a value that outlived a failed pass.
+ */
+const buildHarness = (
+	rows: Row[],
+	options: {
+		failThreadUpdates?: number;
+		bodyStored?: boolean;
+	} = {},
+): Harness => {
+	const messageUpdates: Array<{
+		messageId: string;
+		input: UpdateMessageInput;
+	}> = [];
+	const threadUpdates: ThreadUpdate[] = [];
+	const writeOrder: string[] = [];
+	let threadUpdateAttempts = 0;
+
+	const message = {
+		messageId: "m-1",
+		mailboxId: "mb-inbox",
+		uid: 1,
+		category: MessageCategory.uncategorized,
+		...(options.bodyStored === false
+			? {}
+			: { bodyStorageKey: "s3://bodies/m-1" }),
+	} as unknown as MessageItem;
+
+	const messageService = {
+		get: async () => message,
+		update: async (messageId: string, input: UpdateMessageInput) => {
+			writeOrder.push("message");
+			messageUpdates.push({ messageId, input });
+			Object.assign(message, input);
+		},
+	} as unknown as IMessageRepository;
+
+	const threadMessageService = {
+		findAllByMessageId: async () => rows,
+		// Load-bearing, not a leftover: the current code never calls it, but
+		// reverting body-sync.ts to reproduce these failures does. Deleting it
+		// makes the fail-before run throw instead of demonstrating the defect.
+		getByMessageId: async () => rows[0],
+		update: async (
+			_accountConfigId: string,
+			threadMessageId: string,
+			input: UpdateThreadMessageInput,
+			updateOptions?: { composites?: Record<string, unknown> },
+		) => {
+			threadUpdateAttempts++;
+			if (threadUpdateAttempts <= (options.failThreadUpdates ?? 0)) {
+				throw new Error("thread_message write failed");
+			}
+			writeOrder.push("thread");
+			threadUpdates.push({
+				threadMessageId,
+				input,
+				composites: updateOptions?.composites,
+			});
+			const row = rows.find((r) => r.threadMessageId === threadMessageId);
+			if (row) Object.assign(row, input);
+		},
+	} as unknown as IThreadMessageRepository;
+
+	const storageService = {
+		retrieve: async () => LINKEDIN_EML,
+		storeMessageBody: async () => ({ uri: "s3://bodies/m-1" }),
+		storeParsedBody: async () => {},
+		listBodyParts: async () => [],
+	} as unknown as StorageService;
+
+	const service = new BodySyncService(
+		messageService,
+		storageService,
+		threadMessageService,
+		{ incrementInboundCount: async () => {} } as unknown as IAddressRepository,
+		{ listBodyParts: async () => [] } as unknown as IEnvelopeRepository,
+		{ info: () => {}, error: () => {} },
+	);
+
+	return {
+		service,
+		message,
+		rows,
+		messageUpdates,
+		threadUpdates,
+		writeOrder,
+	};
+};
+
+const backfill = (harness: Harness) =>
+	harness.service.syncBodies(["m-1"], "acc-1", "cfg-1", "INBOX", async () => {
+		throw new Error("the backfill must not open IMAP");
+	});
+
+const syncFromImap = (harness: Harness) =>
+	harness.service.fetchAndGetBody(
+		"m-1",
+		"acc-1",
+		"cfg-1",
+		"INBOX",
+		async () =>
+			({
+				openBox: async () => {},
+				fetchMessageBody: async () => LINKEDIN_EML,
+			}) as unknown as IImapConnection,
+	);
+
+describe("the classification backfill survives an interrupted write", () => {
+	it("leaves the Message unclassified when the ThreadMessage write fails, so the retry runs again", async () => {
+		const harness = buildHarness([buildRow({ threadMessageId: "tm-1" })], {
+			failThreadUpdates: 1,
+		});
+
+		const failed = await backfill(harness);
+
+		assert.deepEqual(failed.failedMessageIds, ["m-1"]);
+		assert.equal(harness.message.category, MessageCategory.uncategorized);
+		assert.deepEqual(harness.messageUpdates, []);
+
+		const retried = await backfill(harness);
+
+		assert.deepEqual(retried.failedMessageIds, []);
+		assert.equal(harness.message.category, MessageCategory.social);
+		assert.equal(harness.rows[0].category, MessageCategory.social);
+	});
+
+	it("writes the Message only after the denormalized row is durable", async () => {
+		const harness = buildHarness([buildRow({ threadMessageId: "tm-1" })]);
+
+		await backfill(harness);
+
+		assert.deepEqual(harness.writeOrder, ["thread", "message"]);
+	});
+});
+
+describe("denormalization reaches every row a message has", () => {
+	it("carries the backfilled category onto all of a message's rows", async () => {
+		const harness = buildHarness([
+			buildRow({ threadMessageId: "tm-inbox", mailboxId: "mb-inbox" }),
+			buildRow({
+				threadMessageId: "tm-archive",
+				mailboxId: "mb-archive",
+				isRead: true,
+			}),
+		]);
+
+		await backfill(harness);
+
+		assert.deepEqual(
+			harness.rows.map((r) => r.category),
+			[MessageCategory.social, MessageCategory.social],
+		);
+	});
+
+	it("builds the composite block from each row rather than reusing the first", async () => {
+		const harness = buildHarness([
+			buildRow({ threadMessageId: "tm-inbox", mailboxId: "mb-inbox" }),
+			buildRow({
+				threadMessageId: "tm-archive",
+				mailboxId: "mb-archive",
+				isRead: true,
+			}),
+		]);
+
+		await backfill(harness);
+
+		assert.deepEqual(
+			harness.threadUpdates.map((u) => ({
+				threadMessageId: u.threadMessageId,
+				mailboxId: u.composites?.mailboxId,
+				isRead: u.composites?.isRead,
+			})),
+			[
+				{ threadMessageId: "tm-inbox", mailboxId: "mb-inbox", isRead: false },
+				{
+					threadMessageId: "tm-archive",
+					mailboxId: "mb-archive",
+					isRead: true,
+				},
+			],
+		);
+	});
+
+	it("fans the snippet and the list id out to every row on the sync path", async () => {
+		// A snippet and a List-Id belong to the message, not to the mailbox a row
+		// happens to name, so every row carries them.
+		const harness = buildHarness(
+			[
+				buildRow({ threadMessageId: "tm-inbox", mailboxId: "mb-inbox" }),
+				buildRow({ threadMessageId: "tm-archive", mailboxId: "mb-archive" }),
+			],
+			{ bodyStored: false },
+		);
+
+		await syncFromImap(harness);
+
+		for (const row of harness.rows) {
+			assert.equal(row.category, MessageCategory.social);
+			assert.equal(row.listId, "invitations.linkedin.com");
+			assert.equal(row.snippet, "invitation body text");
+		}
+	});
+
+	it("writes nothing for a row that already carries every value", async () => {
+		const harness = buildHarness([
+			buildRow({
+				threadMessageId: "tm-inbox",
+				mailboxId: "mb-inbox",
+				category: MessageCategory.social,
+				snippet: "invitation body text",
+				listId: "invitations.linkedin.com",
+			}),
+			buildRow({ threadMessageId: "tm-archive", mailboxId: "mb-archive" }),
+		]);
+
+		await backfill(harness);
+
+		assert.deepEqual(
+			harness.threadUpdates.map((u) => u.threadMessageId),
+			["tm-archive"],
+		);
+	});
+});
+
+describe("the classification backfill writes the whole denormalized set", () => {
+	// A copied message inherits its source's stored body AND its decided
+	// category, so the full body-store path skips it and this path's guard
+	// returns early — and nothing but these two paths ever writes `listId`. The
+	// backfill passing only `category` left every copy's `list_id` NULL for good.
+	it("carries the list id and the snippet, not just the category", async () => {
+		const harness = buildHarness([buildRow({ threadMessageId: "tm-1" })]);
+
+		await backfill(harness);
+
+		assert.deepEqual(harness.threadUpdates.length, 1);
+		assert.deepEqual(harness.threadUpdates[0].input, {
+			category: MessageCategory.social,
+			snippet: "invitation body text",
+			listId: "invitations.linkedin.com",
+		});
+	});
+});

package/src/body-sync-filter.test.ts

@@ -102,15 +102,17 @@ const buildHarness = (
 	} as unknown as IMessageRepository;
 
 	const threadMessageService = {
-		getByMessageId: async () => ({
-			threadMessageId: "tm-1",
-			sentDate: 1,
-			mailboxId: message.mailboxId,
-			isRead: false,
-			isDeleted: false,
-			hasStars: false,
-			hasAttachment: false,
-		}),
+		findAllByMessageId: async () => [
+			{
+				threadMessageId: "tm-1",
+				sentDate: 1,
+				mailboxId: message.mailboxId,
+				isRead: false,
+				isDeleted: false,
+				hasStars: false,
+				hasAttachment: false,
+			},
+		],
 		update: async () => {},
 	} as unknown as IThreadMessageRepository;
 

package/src/body-sync-quarantine.test.ts

@@ -78,15 +78,17 @@ const buildHarness = (options: {
 		messageService,
 		storageService,
 		{
-			getByMessageId: async () => ({
-				threadMessageId: "tm-1",
-				sentDate: 1,
-				mailboxId: "mbx-1",
-				isRead: false,
-				isDeleted: false,
-				hasStars: false,
-				hasAttachment: false,
-			}),
+			findAllByMessageId: async () => [
+				{
+					threadMessageId: "tm-1",
+					sentDate: 1,
+					mailboxId: "mbx-1",
+					isRead: false,
+					isDeleted: false,
+					hasStars: false,
+					hasAttachment: false,
+				},
+			],
 			update: async () => {},
 		} as unknown as IThreadMessageRepository,
 		{} as unknown as IAddressRepository,

package/src/body-sync.ts

@@ -138,6 +138,37 @@ const toFilterMessage = (parsed: ParsedMail): FilterMessage => ({
 	listId: extractListId(parsed),
 });
 
+const SNIPPET_LENGTH = 256;
+
+/**
+ * The snippet the list row shows, from whichever body part carries text. Shared
+ * by both paths that denormalize onto the ThreadMessage so they cannot derive it
+ * differently.
+ */
+const extractSnippet = (parsed: ParsedMail): string =>
+	extractSnippetFromEmail(
+		parsed.text,
+		typeof parsed.html === "string" ? parsed.html : undefined,
+		SNIPPET_LENGTH,
+	);
+
+/**
+ * A row is skipped only when every field the denormalization would write
+ * already matches. `snippet` and `listId` are absent from the update when the
+ * message has neither, and an absent field is not a mismatch.
+ */
+const alreadyDenormalized = (
+	row: ThreadMessageItem,
+	update: {
+		category: ThreadMessageCategory;
+		snippet?: string;
+		listId?: string;
+	},
+): boolean =>
+	row.category === update.category &&
+	(update.snippet === undefined || row.snippet === update.snippet) &&
+	(update.listId === undefined || row.listId === update.listId);
+
 export const toParsedBody = (parsed: ParsedMail): ParsedBody => ({
 	text: parsed.text ?? null,
 	html: typeof parsed.html === "string" ? parsed.html : null,
@@ -942,12 +973,26 @@ export class BodySyncService {
 		const parsed = await parseMessageBody(body);
 		const classification = this.classifyMessage(parsed);
 
-		await this.messageService.update(message.messageId, classification);
+		// Same order as {@link applyPostStoreSteps}, for the same reason: the
+		// signal the skip guard reads is written last. `message.category` is that
+		// signal here, so a failure between the two writes leaves both undone and
+		// the requeued retry redoes both. Writing the Message first strands the
+		// denormalized row at `uncategorized` forever — the guard is satisfied and
+		// the retry returns early (issue #320).
+		// The same three denormalized fields `updateSnippets` writes on the
+		// full body-store path, not just the category. A copied message inherits
+		// `bodyStorageKey` and a decided category from its source, so it reaches
+		// neither that path nor this one's classification — but nothing else ever
+		// writes `listId`, so leaving it out here made a copy's `list_id`
+		// permanently NULL. Both are derived from the same bytes already in hand.
 		await this.denormalizeCategory(
 			accountConfigId,
 			message.messageId,
 			classification.category,
+			extractSnippet(parsed),
+			extractListId(parsed),
 		);
+		await this.messageService.update(message.messageId, classification);
 
 		this.log.info(
 			{ messageId: message.messageId, category: classification.category },
@@ -1445,13 +1490,7 @@ export class BodySyncService {
 		// two apart and quarantine only this one (issue #72).
 		const parsed = await parseMessageBody(body);
 
-		// Extract snippet from text or HTML content
-		const snippet = extractSnippetFromEmail(
-			parsed.text,
-			typeof parsed.html === "string" ? parsed.html : undefined,
-			256,
-		);
-
+		const snippet = extractSnippet(parsed);
 		const category = classifyByHeaders(parsed);
 		const listId = extractListId(parsed);
 
@@ -1472,15 +1511,30 @@ export class BodySyncService {
 	}
 
 	/**
-	 * Write the denormalized `category` (and optionally the snippet) onto the
-	 * message's ThreadMessage row — the copy the list/search read path serves
-	 * without a per-row Message fetch.
+	 * Write the denormalized `category` (and optionally the snippet and the
+	 * normalized `List-Id`) onto EVERY ThreadMessage row the message has — the
+	 * copy the list/search read path serves without a per-row Message fetch.
 	 *
-	 * The ThreadMessage is looked up by messageId (GSI), so it does not depend
-	 * on the RFC822 Message-ID header — a headerless message still gets
-	 * denormalized, matching the unconditional Message.category write. The full
-	 * composite set is passed so that a future key-attribute addition touching
-	 * the lsi3/lsi4/lsi5/gsi2 sort keys keeps the index rows consistent.
+	 * More than one row per messageId is schema-legal but not normally produced,
+	 * and this iterates for the same reason `message-move.ts` does (see the model
+	 * stated at its `deleteThreadMessagesForMessage`): the key permits it and
+	 * nothing enforces otherwise. It is NOT the second mailbox a message appears
+	 * in — `deriveMessageId` and `deriveThreadMessageId` are both
+	 * mailbox-independent, so INBOX and Archive resolve to one row, and a copy
+	 * gets its own messageId. The reachable case is thread-root drift: the same
+	 * message re-saved under different `References`, which mints a second
+	 * threadId and so a second row. Iterating is therefore hardening against a
+	 * legal state, not a repair for one the sync path manufactures, which is why
+	 * the tree's other single-row `messageId` lookups are correct as they stand.
+	 * `flag-queue.ts` iterates the same list.
+	 *
+	 * Rows are looked up by messageId, so this does not depend on the RFC822
+	 * Message-ID header — a headerless message still gets denormalized, matching
+	 * the unconditional Message.category write. The composite set is built per
+	 * row, never reused: `mailboxId` and `isRead` can differ between two rows for
+	 * one message, and it is passed at all so that a future key-attribute
+	 * addition touching the lsi3/lsi4/lsi5/gsi2 sort keys keeps the index rows
+	 * consistent.
 	 */
 	private async denormalizeCategory(
 		accountConfigId: string,
@@ -1489,29 +1543,39 @@ export class BodySyncService {
 		snippet?: string,
 		listId?: string,
 	): Promise<void> {
-		const threadMessage = await this.threadMessageService.getByMessageId(
+		const rows = await this.threadMessageService.findAllByMessageId(
 			accountConfigId,
 			messageId,
 		);
+		if (rows.length === 0) {
+			throw new NotFoundError(
+				`ThreadMessage not found for message ${messageId}`,
+			);
+		}
 
-		await this.threadMessageService.update(
-			accountConfigId,
-			threadMessage.threadMessageId,
-			{
-				category,
-				...(snippet ? { snippet } : {}),
-				...(listId ? { listId } : {}),
-			},
-			{
-				composites: {
-					sentDate: threadMessage.sentDate,
-					mailboxId: threadMessage.mailboxId,
-					isRead: threadMessage.isRead,
-					isDeleted: threadMessage.isDeleted,
-					hasStars: threadMessage.hasStars,
-					hasAttachment: threadMessage.hasAttachment,
+		const update = {
+			category,
+			...(snippet ? { snippet } : {}),
+			...(listId ? { listId } : {}),
+		};
+
+		for (const row of rows) {
+			if (alreadyDenormalized(row, update)) continue;
+			await this.threadMessageService.update(
+				accountConfigId,
+				row.threadMessageId,
+				update,
+				{
+					composites: {
+						sentDate: row.sentDate,
+						mailboxId: row.mailboxId,
+						isRead: row.isRead,
+						isDeleted: row.isDeleted,
+						hasStars: row.hasStars,
+						hasAttachment: row.hasAttachment,
+					},
 				},
-			},
-		);
+			);
+		}
 	}
 }

package/src/mailbox-sync.test.ts

@@ -4,7 +4,11 @@ import type {
 	IMailboxRepository,
 	IMailboxSpecialUseRepository,
 } from "@remit/data-ports";
-import { MailboxCursorState, MailboxSpecialUse } from "@remit/domain-enums";
+import {
+	MailboxCursorState,
+	MailboxSpecialUse,
+	MailboxSyncStatus,
+} from "@remit/domain-enums";
 import { parseImapAttributes } from "./attribute-mapper.js";
 import { MailboxSyncService } from "./mailbox-sync.js";
 import type { IImapConnection, ImapNamespaces } from "./types.js";
@@ -180,3 +184,128 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 		assert.equal("cursorState" in (uidValidityUpdate ?? {}), false);
 	});
 });
+
+describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending folders (#290)", () => {
+	const namespaces: ImapNamespaces = {
+		personal: [{ prefix: "", delimiter: "/" }],
+		other: [],
+		shared: [],
+	};
+
+	// The server lists only INBOX: neither user folder is on it yet.
+	const serverConnection = (): IImapConnection =>
+		({
+			getNamespaces: async () => namespaces,
+			listMailboxes: async () => [
+				{
+					fullPath: "INBOX",
+					name: "INBOX",
+					delimiter: "/",
+					attributes: [],
+					parentPath: null,
+				},
+			],
+			getMailboxStatus: async () => ({
+				messages: 0,
+				recent: 0,
+				unseen: 0,
+				uidNext: 1,
+				uidValidity: 1,
+				highestModseq: "0",
+				deletedCount: 0,
+			}),
+		}) as unknown as IImapConnection;
+
+	const buildServices = (
+		existing: Array<{
+			mailboxId: string;
+			fullPath: string;
+			syncStatus?: string;
+		}>,
+	) => {
+		const deleted: string[] = [];
+		const mailboxService = {
+			listByAccount: async () => ({
+				items: existing.map((m) => ({
+					mailboxId: m.mailboxId,
+					fullPath: m.fullPath,
+					uidNext: 1,
+					uidValidity: 1,
+					messageCount: 0,
+					unseenCount: 0,
+					deletedCount: 0,
+					highestModseq: "0",
+					specialUse: undefined,
+					syncStatus: m.syncStatus,
+				})),
+				continuationToken: undefined,
+			}),
+			update: async () => ({}),
+			delete: async (_accountId: string, mailboxId: string) => {
+				deleted.push(mailboxId);
+			},
+			create: async () => ({}),
+		} as unknown as IMailboxRepository;
+
+		const specialUseService = {
+			listByMailboxId: async () => [],
+			deleteByMailboxId: async () => undefined,
+			createMany: async () => undefined,
+		} as unknown as IMailboxSpecialUseRepository;
+
+		return { mailboxService, specialUseService, deleted };
+	};
+
+	it("keeps a pending folder the server has not listed yet", async () => {
+		// The folder was just created locally; MAILBOX_CREATE has not reached the
+		// server, so the LIST omits it. Deleting the row here races the create and
+		// wedges the account's mailbox-sync FIFO group for a full visibility window.
+		const { mailboxService, specialUseService, deleted } = buildServices([
+			{
+				mailboxId: "inbox",
+				fullPath: "INBOX",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+			{
+				mailboxId: "pending-folder",
+				fullPath: "New Folder",
+				syncStatus: MailboxSyncStatus.pending,
+			},
+		]);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection(),
+		);
+
+		assert.deepEqual(deleted, []);
+		assert.equal(result.deleted, 0);
+	});
+
+	it("still deletes a synced folder that has left the server", async () => {
+		// A folder that was confirmed on the server and is now gone is a genuine
+		// server-side deletion; the reconcile must still reap it.
+		const { mailboxService, specialUseService, deleted } = buildServices([
+			{
+				mailboxId: "inbox",
+				fullPath: "INBOX",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+			{
+				mailboxId: "synced-gone",
+				fullPath: "Old Folder",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+		]);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection(),
+		);
+
+		assert.deepEqual(deleted, ["synced-gone"]);
+		assert.equal(result.deleted, 1);
+	});
+});

package/src/mailbox-sync.ts

@@ -13,6 +13,7 @@ import type {
 import {
 	MailboxCursorState,
 	MailboxSpecialUse,
+	MailboxSyncStatus,
 	NamespaceType,
 } from "@remit/domain-enums";
 import pMap from "p-map";
@@ -198,13 +199,21 @@ export class MailboxSyncService {
 
 		// Handle deleted mailboxes (exist in DB but not on server)
 		for (const existing of existingMailboxes) {
-			if (!seenPaths.has(existing.fullPath)) {
-				await this.mailboxService.delete(account.accountId, existing.mailboxId);
-				console.info(
-					`Deleted mailbox: ${existing.mailboxId} (${existing.fullPath})`,
-				);
-				result.deleted++;
-			}
+			if (seenPaths.has(existing.fullPath)) continue;
+			// A `pending` row is a folder the user just created (or renamed) whose
+			// MAILBOX_CREATE/RENAME has not yet reached the server, so its absence
+			// from the LIST is expected, not a server-side deletion. Deleting it
+			// races the create: the row vanishes, then MAILBOX_CREATE fails with
+			// NotFoundError trying to mark it synced, and — sharing this account's
+			// mailboxes FIFO group — that un-acked failure stalls every later
+			// mailbox sync for the queue's whole visibility window (#290). Leave
+			// pending rows to the create/rename flow that owns them.
+			if (existing.syncStatus === MailboxSyncStatus.pending) continue;
+			await this.mailboxService.delete(account.accountId, existing.mailboxId);
+			console.info(
+				`Deleted mailbox: ${existing.mailboxId} (${existing.fullPath})`,
+			);
+			result.deleted++;
 		}
 
 		return result;

package/src/message-sync-category.test.ts

@@ -0,0 +1,132 @@
+/**
+ * A ThreadMessage row created for a message that is already classified used to
+ * start at `uncategorized` and stay there: `denormalizeCategory` runs at
+ * body-sync, and body-sync skips a message whose body is already stored (issue
+ * #320). A second mailbox does not produce such a row — the ids are
+ * mailbox-independent — but thread-root drift does: the same message re-saved
+ * under different `References` mints a second threadId, so a new row for a
+ * Message whose category is already decided.
+ *
+ * The row now carries the category of the Message the same save just wrote.
+ * These pin the create input, which is where the threading can go wrong; the
+ * stored round-trip belongs to #322's conformance suite. The negative case is
+ * here because parameter threading is exactly the change that starts writing the
+ * wrong value when a caller's variable is undefined — and `uncategorized` is the
+ * declared pending state, never to be folded into `personal` (issue #45).
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	CreateMessageInput,
+	CreateThreadMessageInput,
+	IAddressRepository,
+	IEnvelopeRepository,
+	IMailboxRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+	MessageItem,
+	ThreadMessageItem,
+} from "@remit/data-ports";
+import { MessageCategory } from "@remit/domain-enums";
+import type { ManagedConnectionFactory } from "./connection-factory.js";
+import { MessageSyncService } from "./message-sync.js";
+import type { ImapMessage } from "./types.js";
+
+const envelope = {
+	date: new Date(0).toISOString(),
+	messageId: "<root@example.com>",
+	subject: "Subject",
+	from: [{ name: "Sender", mailbox: "sender", host: "example.com" }],
+	sender: [],
+	replyTo: [],
+	to: [],
+	cc: [],
+	bcc: [],
+	inReplyTo: "",
+};
+
+const imapMessage = {
+	uid: 42,
+	seq: 1,
+	size: 100,
+	internalDate: new Date(0),
+	flags: [],
+	envelope,
+} as unknown as ImapMessage;
+
+const stub = <T>(): T => ({}) as T;
+
+/**
+ * Drive the real save path so the value the ThreadMessage gets is the one the
+ * Message write returned, not one a test handed to a private method.
+ */
+const saveIntoMailbox = async (
+	storedCategory: MessageItem["category"],
+): Promise<CreateThreadMessageInput> => {
+	const inputs: CreateThreadMessageInput[] = [];
+
+	const messageService = {
+		upsertWithStatus: async (input: CreateMessageInput) => ({
+			item: {
+				...input,
+				category: storedCategory,
+			} as unknown as MessageItem,
+			created: false,
+		}),
+	} as unknown as IMessageRepository;
+
+	const threadMessageService = {
+		create: async (input: CreateThreadMessageInput) => {
+			inputs.push(input);
+			return input as unknown as ThreadMessageItem;
+		},
+	} as unknown as IThreadMessageRepository;
+
+	const envelopeService = {
+		upsertEnvelope: async () => {},
+		upsertBodyParts: async () => {},
+	} as unknown as IEnvelopeRepository;
+
+	const addressService = {
+		upsertAddress: async () => {},
+		upsertEnvelopeAddress: async () => {},
+	} as unknown as IAddressRepository;
+
+	const service = new MessageSyncService(
+		stub<ManagedConnectionFactory>(),
+		stub<IMailboxRepository>(),
+		messageService,
+		envelopeService,
+		addressService,
+		threadMessageService,
+	);
+
+	await (
+		service as unknown as {
+			saveMessage: (
+				mailboxId: string,
+				accountId: string,
+				accountConfigId: string,
+				msg: ImapMessage,
+			) => Promise<unknown>;
+		}
+	).saveMessage("mbx-1", "acct-1", "cfg-1", imapMessage);
+
+	assert.equal(inputs.length, 1);
+	const [input] = inputs;
+	assert.ok(input);
+	return input;
+};
+
+describe("a created ThreadMessage carries the Message's category", () => {
+	it("gives a row for an already-classified message that message's category", async () => {
+		const input = await saveIntoMailbox(MessageCategory.newsletter);
+		assert.equal(input.category, MessageCategory.newsletter);
+	});
+
+	it("leaves a row for a new, unclassified message at uncategorized", async () => {
+		const input = await saveIntoMailbox(MessageCategory.uncategorized);
+		assert.equal(input.category, MessageCategory.uncategorized);
+	});
+});

package/src/message-sync-flags.test.ts

@@ -9,7 +9,7 @@ import type {
 	IThreadMessageRepository,
 	ThreadMessageItem,
 } from "@remit/data-ports";
-import { MessageSystemFlag } from "@remit/domain-enums";
+import { MessageCategory, MessageSystemFlag } from "@remit/domain-enums";
 import type { ManagedConnectionFactory } from "./connection-factory.js";
 import { MessageSyncService } from "./message-sync.js";
 import type { ImapEnvelope } from "./types.js";
@@ -72,6 +72,7 @@ type CreateThreadForMessage = (
 	sentDate: number,
 	envelope: ImapEnvelope,
 	flags: string[],
+	category: ThreadMessageItem["category"],
 	references?: string[],
 	hasAttachment?: boolean,
 ) => Promise<void>;
@@ -103,6 +104,7 @@ const createThreadWithFlags = async (
 		now,
 		envelope,
 		flags,
+		MessageCategory.uncategorized,
 	);
 
 	assert.equal(inputs.length, 1);

package/src/message-sync.ts

@@ -1317,6 +1317,15 @@ export class MessageSyncService {
 				sentDate,
 				envelope,
 				msg.flags,
+				// The category of the Message this same save just wrote. A new
+				// message is `uncategorized` until body-sync classifies it; a row
+				// created for a Message that is ALREADY classified takes the decided
+				// value rather than sitting stale forever behind a body-sync pass that
+				// will skip it. That happens on thread-root drift — the same message
+				// re-saved under different `References` mints a second threadId and so
+				// a second row — not on a second mailbox, which resolves to the row
+				// that already exists (issue #320).
+				item.category,
 				msg.references,
 				hasAttachment,
 			);
@@ -1400,6 +1409,10 @@ export class MessageSyncService {
 	 * 3. Fall back to Message-ID (this message is a thread root)
 	 *
 	 * This ensures proper threading even when messages arrive out of order.
+	 *
+	 * `category` is the value the caller already holds from the Message it just
+	 * wrote, so the row starts out agreeing with it rather than defaulting to
+	 * `uncategorized` behind an already-classified message.
 	 */
 	private async createThreadForMessage(
 		threadMessageService: IThreadMessageRepository,
@@ -1412,6 +1425,7 @@ export class MessageSyncService {
 		sentDate: number,
 		envelope: ImapEnvelope,
 		flags: string[],
+		category: ThreadMessageItem["category"],
 		references?: string[],
 		hasAttachment = false,
 	): Promise<void> {
@@ -1484,6 +1498,7 @@ export class MessageSyncService {
 				hasAttachment,
 				hasStars,
 				star: hasStars ? StarColor.Yellow : StarColor.None,
+				category,
 			})
 			.catch((error: unknown) => {
 				// Ignore conflict errors (idempotent create)