@teamscala/service-boot 0.23.516 → 0.23.518

package/src/handlers/messaging-send-reconcile-logic.ts

@@ -1,83 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Pure reconciliation logic for the outbound-dispatch coverage half of
- * `messaging-send-recording-watch`: diff GOWA's outbound message list against
- * the recorded provider ids and shape the backfill rows — a send dispatched
- * outside every recording chokepoint exists only in GOWA's list (2026-08-26).
- */
-
-/** One outbound message from GOWA `getChatMessages` with is_from_me=true. */
-export interface GowaOutboundMessage {
-	id: string;
-	chat_jid: string;
-	content: string | null;
-	timestamp: string | null;
-	is_from_me: boolean;
-}
-
-/** A GOWA-outbound message with no messaging_logs row — the backfill input. */
-export interface MissingSend {
-	id: string;
-	chatJid: string;
-	content: string | null;
-	timestamp: string;
-}
-
-/**
- * Diff GOWA's outbound truth against the recorded provider ids. Only
- * `is_from_me` messages count (the bridge device's own sends — inbound arrives
- * by webhook and records itself). Messages newer than the settle window are
- * held back one tick so the dispatch-time recorder's own write can land.
- */
-export function diffOutboundSends(
-	messages: GowaOutboundMessage[],
-	recordedIds: Set<string>,
-	now: Date,
-	settleMs: number,
-): MissingSend[] {
-	const missing: MissingSend[] = [];
-	for (const message of messages) {
-		if (!message.is_from_me) continue;
-		if (!message.id || recordedIds.has(message.id)) continue;
-		const at = Date.parse(message.timestamp ?? "");
-		if (Number.isNaN(at)) continue;
-		if (at > now.getTime() - settleMs) continue;
-		missing.push({
-			id: message.id,
-			chatJid: message.chat_jid,
-			content: message.content,
-			timestamp: new Date(at).toISOString(),
-		});
-	}
-	return missing;
-}
-
-/** The messaging_logs row that makes a bypassed send reconstructible. */
-export function buildBackfillRow(missing: MissingSend): {
-	id: string;
-	platform: "whatsapp";
-	direction: "outbound";
-	event_type: "sent";
-	external_chat_id: string;
-	user_phone: string;
-	external_msg_id: string;
-	content: string | null;
-	payload: Record<string, unknown>;
-	timestampIso: string;
-} {
-	return {
-		id: crypto.randomUUID(),
-		platform: "whatsapp",
-		direction: "outbound",
-		event_type: "sent",
-		external_chat_id: missing.chatJid,
-		user_phone: missing.chatJid,
-		external_msg_id: missing.id,
-		content: missing.content,
-		payload: { send_kind: "gowa-reconcile" },
-		timestampIso: missing.timestamp,
-	};
-}

package/src/handlers/messaging-send-recording-logic.test.ts

@@ -1,86 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { describe, expect, test } from "bun:test";
-import {
-	buildUnrecordedPayload,
-	detectUnrecordedSends,
-	type UnrecordedSendRow,
-} from "./messaging-send-recording-logic.ts";
-
-const T = (iso: string) => new Date(iso);
-
-function row(id: string, iso: string, sendKind: string | null = null): UnrecordedSendRow {
-	return { id, created_at: T(iso), external_chat_id: "447@s.whatsapp.net", send_kind: sendKind };
-}
-
-describe("detectUnrecordedSends", () => {
-	test("zero rows is healthy — no finding, no event", () => {
-		expect(detectUnrecordedSends([], 5)).toBeNull();
-	});
-
-	test("one row yields the finding with matching bounds", () => {
-		const finding = detectUnrecordedSends([row("a", "2026-08-20T05:54:37.715Z")], 5);
-		expect(finding).not.toBeNull();
-		expect(finding!.unrecordedCount).toBe(1);
-		expect(finding!.firstAt).toEqual(T("2026-08-20T05:54:37.715Z"));
-		expect(finding!.lastAt).toEqual(T("2026-08-20T05:54:37.715Z"));
-	});
-
-	test("unordered rows are ordered into first/last bounds", () => {
-		// The live pre-fix rows, newest first as a LIMIT-descending read might return.
-		const finding = detectUnrecordedSends(
-			[
-				row("c", "2026-08-20T08:37:15.667Z"),
-				row("a", "2026-08-20T05:54:37.715Z"),
-				row("b", "2026-08-20T08:36:49.149Z"),
-			],
-			5,
-		);
-		expect(finding!.unrecordedCount).toBe(3);
-		expect(finding!.firstAt).toEqual(T("2026-08-20T05:54:37.715Z"));
-		expect(finding!.lastAt).toEqual(T("2026-08-20T08:37:15.667Z"));
-	});
-
-	test("the sample keeps the MOST RECENT rows up to the limit", () => {
-		const rows = [
-			row("a", "2026-08-20T05:54:37.715Z"),
-			row("b", "2026-08-20T08:36:49.149Z"),
-			row("c", "2026-08-20T08:37:15.667Z"),
-		];
-		const finding = detectUnrecordedSends(rows, 2);
-		expect(finding!.sample.map((r) => r.id)).toEqual(["b", "c"]);
-		// The count still reports every row, not just the sample.
-		expect(finding!.unrecordedCount).toBe(3);
-	});
-});
-
-describe("buildUnrecordedPayload", () => {
-	test("carries count, baseline, bounds, and ISO-string sample rows", () => {
-		const finding = detectUnrecordedSends(
-			[row("a", "2026-08-20T08:36:49.149Z", "relay-notify")],
-			5,
-		)!;
-		const payload = buildUnrecordedPayload(finding, "2026-08-20T10:19:00Z");
-		expect(payload).toEqual({
-			unrecordedCount: 1,
-			recordedSince: "2026-08-20T10:19:00Z",
-			firstAt: "2026-08-20T08:36:49.149Z",
-			lastAt: "2026-08-20T08:36:49.149Z",
-			sample: [
-				{
-					id: "a",
-					createdAt: "2026-08-20T08:36:49.149Z",
-					chatId: "447@s.whatsapp.net",
-					sendKind: "relay-notify",
-				},
-			],
-		});
-	});
-});

package/src/handlers/messaging-send-recording-logic.ts

@@ -1,68 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Pure detection logic for the messaging send-recording watch
- * (`messaging-send-recording-watch` handler). Split from the DB-coupled handler
- * so the row-shape decision is unit-testable with zero database dependencies,
- * the same shape as whatsapp-liveness-logic.
- */
-
-/** One outbound messaging_logs row that never recorded its provider message id. */
-export interface UnrecordedSendRow {
-	id: string;
-	created_at: Date;
-	external_chat_id: string | null;
-	send_kind: string | null;
-}
-
-/** The aggregate the handler emits while the failure shape persists. */
-export interface UnrecordedSendFinding {
-	unrecordedCount: number;
-	firstAt: Date;
-	lastAt: Date;
-	sample: UnrecordedSendRow[];
-}
-
-/**
- * Classify freshly-read unrecorded outbound rows. Zero rows is the healthy
- * state (every send recorded its provider id) and yields null — no event,
- * idle-costs-nothing. Any row at/after the baseline is the failure signature
- * handed over 2026-08-20: a send whose provider id was never recorded can
- * never correlate its delivery receipt, so "did it reach the handset" is
- * unanswerable for exactly those sends.
- */
-export function detectUnrecordedSends(
-	rows: UnrecordedSendRow[],
-	sampleLimit: number,
-): UnrecordedSendFinding | null {
-	if (rows.length === 0) return null;
-	const sorted = [...rows].sort((a, b) => a.created_at.getTime() - b.created_at.getTime());
-	return {
-		unrecordedCount: rows.length,
-		firstAt: sorted[0]!.created_at,
-		lastAt: sorted[sorted.length - 1]!.created_at,
-		// The most recent rows are the ones a responder acts on first.
-		sample: sorted.slice(-sampleLimit),
-	};
-}
-
-/** The durable-event payload — ISO strings + the baseline it was read against. */
-export function buildUnrecordedPayload(
-	finding: UnrecordedSendFinding,
-	recordedSince: string,
-): Record<string, unknown> {
-	return {
-		unrecordedCount: finding.unrecordedCount,
-		recordedSince,
-		firstAt: finding.firstAt.toISOString(),
-		lastAt: finding.lastAt.toISOString(),
-		sample: finding.sample.map((row) => ({
-			id: row.id,
-			createdAt: row.created_at.toISOString(),
-			chatId: row.external_chat_id,
-			sendKind: row.send_kind,
-		})),
-	};
-}

package/src/handlers/messaging-send-recording-watch.test.ts

@@ -1,91 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { beforeEach, expect, mock, test } from "bun:test";
-
-const recordEventCalls: Array<{ kind: string; payload: Record<string, unknown> }> = [];
-
-// The live unrecorded rows the query returns — mutated per test.
-let mockRows: Array<{
-	id: string;
-	created_at: Date;
-	external_chat_id: string | null;
-	send_kind: string | null;
-}>;
-let queryArgs: unknown[] = [];
-
-mock.module("@teamscala/db/prisma-registry", () => ({
-	getPrisma: () => ({
-		$queryRawUnsafe: async (_sql: string, ...args: unknown[]) => {
-			queryArgs = args;
-			return mockRows;
-		},
-	}),
-}));
-mock.module("@teamscala/event-log/record-event", () => ({
-	recordEvent: (e: { kind: string; payload: Record<string, unknown> }) => {
-		recordEventCalls.push(e);
-	},
-}));
-// Self-contained in any suite order: another handler test file installs a
-// partial process-global app-loggers mock that leaks into this one, so this
-// file pins the logger shape it needs rather than depending on run order.
-mock.module("@teamscala/logger/app-loggers", () => ({
-	getAppLogger: () => ({
-		info: () => {},
-		warn: () => {},
-		error: () => {},
-	}),
-}));
-
-const { messagingSendRecordingWatch } = await import("./messaging-send-recording-watch.ts");
-
-const CONFIG = {
-	recorded_since: "2026-08-01T00:00:00Z",
-	sample_limit: 2,
-} as never;
-
-beforeEach(() => {
-	recordEventCalls.length = 0;
-	queryArgs = [];
-});
-
-test("unrecorded rows at/after the baseline emit one messaging.send.unrecorded event", async () => {
-	mockRows = [
-		{ id: "a", created_at: new Date("2026-08-20T05:54:37.715Z"), external_chat_id: "447@s.whatsapp.net", send_kind: null },
-		{ id: "b", created_at: new Date("2026-08-20T08:36:49.149Z"), external_chat_id: "447@s.whatsapp.net", send_kind: null },
-		{ id: "c", created_at: new Date("2026-08-20T08:37:15.667Z"), external_chat_id: "447@s.whatsapp.net", send_kind: null },
-	];
-	await messagingSendRecordingWatch({ config: CONFIG });
-
-	expect(recordEventCalls).toHaveLength(1);
-	expect(recordEventCalls[0]!.kind).toBe("messaging.send.unrecorded");
-	expect(recordEventCalls[0]!.payload).toMatchObject({
-		unrecordedCount: 3,
-		recordedSince: "2026-08-01T00:00:00Z",
-	});
-	// The query reads the baseline as a bound — the predicate's timestamp is
-	// part of the failure signature, not decoration.
-	expect(queryArgs).toEqual(["2026-08-01T00:00:00Z"]);
-});
-
-test("healthy shape (every send recorded) emits nothing", async () => {
-	mockRows = [];
-	await messagingSendRecordingWatch({ config: CONFIG });
-	expect(recordEventCalls).toEqual([]);
-});
-
-test("missing recorded_since baseline skips the query rather than sweeping pre-fix history", async () => {
-	mockRows = [
-		{ id: "historic", created_at: new Date("2026-08-01T00:00:00Z"), external_chat_id: null, send_kind: null },
-	];
-	await messagingSendRecordingWatch({ config: {} as never });
-	expect(recordEventCalls).toEqual([]);
-	expect(queryArgs).toEqual([]);
-});

package/src/handlers/messaging-send-recording-watch.ts

@@ -1,244 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * The `messaging-send-recording-watch` pg-boss handler — watches the durable
- * row shape that makes delivery acks correlatable: every outbound
- * messaging_logs row created at/after `recorded_since` must carry the provider
- * message id (`external_msg_id`). A row without it is a send whose
- * `message.ack` receipt can never correlate — the regression fixed
- * 2026-08-20T10:19Z (the single send path in messaging-service outbound.rs),
- * whose silent return is otherwise invisible: the ack-time "cannot correlate"
- * warning fires only when a live webhook consumer receives an ack, so a dead
- * consumer or a recording break both read as healthy silence. This watch
- * reads the shared platform database directly — independent of the webhook
- * consumer, GOWA, and any scale-to-zero surface — and emits one
- * `messaging.send.unrecorded` durable event per tick while the shape
- * persists. Thresholding (duration + recurrence), episode dedup, and operator
- * delivery belong to the platform-fault escalator, not here.
- *
- * Registered under `@teamscala/service-boot:messaging-send-recording-watch`.
- */
-import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
-import { getPrisma } from "@teamscala/db/prisma-registry";
-import { recordEvent } from "@teamscala/event-log/record-event";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
-import {
-	buildUnrecordedPayload,
-	detectUnrecordedSends,
-	type UnrecordedSendRow,
-} from "./messaging-send-recording-logic.ts";
-import {
-	buildBackfillRow,
-	diffOutboundSends,
-	type GowaOutboundMessage,
-} from "./messaging-send-reconcile-logic.ts";
-import {
-	selectChatsToSweep,
-	type GowaChatSummary,
-} from "./messaging-send-sweep-selection.ts";
-import { getSystemIdentity } from "./whatsapp-liveness.ts";
-
-const DEFAULT_SAMPLE_LIMIT = 5;
-/** Bounds the per-tick read while a break runs for weeks; far above daily volume. */
-const QUERY_ROW_CAP = 1000;
-/** GOWA page size cap (the spec's maximum for both listChats and messages). */
-const GOWA_PAGE_LIMIT = 100;
-/** Upper bound on message pages walked per chat per tick. */
-const MAX_MESSAGE_PAGES_PER_CHAT = 5;
-/** A freshly-dispatched send waits this long before the reconcile sweep may
- * claim it — the tool-dispatch recorder writes its row at dispatch, and
- * sweeping sooner would backfill a duplicate of a row about to exist. */
-const RECONCILE_SETTLE_MS = 120_000;
-
-export async function messagingSendRecordingWatch({
-	config,
-}: {
-	config: ScheduledJobConfig;
-}): Promise<void> {
-	const log = getAppLogger();
-
-	// Fail explicit, not historic: without a baseline the query would sweep
-	// pre-fix history and alert on rows that were never promised an id.
-	const recordedSince = config.recorded_since;
-	if (!recordedSince) {
-		log.error(
-			"[messaging-send-recording-watch] scheduled_job row has no recorded_since baseline — skipping (a baseline-less watch would fire on pre-fix history)",
-		);
-		return;
-	}
-
-	const prisma = getPrisma();
-	const rows = await prisma.$queryRawUnsafe<UnrecordedSendRow[]>(
-		`SELECT id, created_at, external_chat_id, payload->>'send_kind' AS send_kind
-		 FROM messaging_logs
-		 WHERE direction = 'outbound'
-			 AND external_msg_id IS NULL
-			 AND created_at >= $1::timestamptz
-		 ORDER BY created_at ASC
-		 LIMIT ${QUERY_ROW_CAP}`,
-		recordedSince,
-	);
-
-	const finding = detectUnrecordedSends(rows, config.sample_limit ?? DEFAULT_SAMPLE_LIMIT);
-	if (!finding) {
-		log.info(
-			`[messaging-send-recording-watch] poll complete — every outbound send at/after ${recordedSince} recorded its provider id`,
-		);
-	} else {
-		const payload = buildUnrecordedPayload(finding, recordedSince);
-		recordEvent({ kind: "messaging.send.unrecorded", payload });
-		log.warn(
-			`[messaging-send-recording-watch] ${finding.unrecordedCount} outbound send(s) at/after ${recordedSince} recorded no provider message id — their delivery receipts can never correlate`,
-			payload,
-		);
-	}
-
-	// Dispatch-coverage reconcile — the row-shape check above can only inspect
-	// rows that EXIST; a send dispatched to GOWA outside every recording
-	// chokepoint (measured 2026-08-26: raw multipart sends delivered with zero
-	// rows) is invisible to it. GOWA's own message list is the authoritative
-	// outbound record, so this sweep backfills what bypassed us. Failure here
-	// must never take the row-shape check down with it.
-	try {
-		const backfilled = await reconcileOutboundDispatches(recordedSince);
-		if (backfilled > 0) {
-			log.warn(
-				`[messaging-send-recording-watch] reconcile: backfilled ${backfilled} outbound send(s) GOWA delivered with no messaging_logs row (dispatched outside the recording surface)`,
-			);
-		}
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		log.warn(`[messaging-send-recording-watch] reconcile sweep failed: ${message}`);
-	}
-}
-
-/** Dispatch one api_gowa_chats action through the central /mcp loopback — the
- * same single sealed-credential surface whatsapp-liveness uses, as the system
- * caller. */
-async function dispatchGowaChats(
-	action: string,
-	params: Record<string, unknown>,
-): Promise<unknown> {
-	const { forwardToolToCentralMcp } = await import(
-		"@teamscala/chat-completion/central-tool-forwarder"
-	);
-	const { userId, organisationId } = await getSystemIdentity();
-	return forwardToolToCentralMcp(
-		"api_gowa_chats",
-		{ action, params },
-		{ userId, organisationId } as Parameters<typeof forwardToolToCentralMcp>[2],
-	);
-}
-
-interface GowaPaged<T> {
-	results?: { data?: T[]; pagination?: { total?: number } };
-}
-
-/**
- * The convergent half of the watch: walk GOWA's chats newest-first for
- * outbound activity at/after the baseline, read each qualifying chat's own
- * sends, and backfill every provider id messaging_logs is missing. Idempotent
- * by external_msg_id — a backfilled row can never be backfilled twice, and the
- * settle window keeps it from racing the dispatch-time recorder.
- */
-async function reconcileOutboundDispatches(recordedSince: string): Promise<number> {
-	const log = getAppLogger();
-	const horizonMs = Date.parse(recordedSince);
-	if (Number.isNaN(horizonMs)) return 0;
-
-	const chatJids: string[] = [];
-	for (let offset = 0; offset < 100 * 20; offset += GOWA_PAGE_LIMIT) {
-		const page = (await dispatchGowaChats("listChats", {
-			limit: GOWA_PAGE_LIMIT,
-			offset,
-		})) as GowaPaged<GowaChatSummary> | undefined;
-		const chats = (page?.results?.data ?? []) as GowaChatSummary[];
-		if (chats.length === 0) break;
-		const { toSweep, mayStopPaging } = selectChatsToSweep(chats, horizonMs);
-		chatJids.push(...toSweep);
-		if (mayStopPaging) break;
-	}
-
-	const outbound: GowaOutboundMessage[] = [];
-	for (const chatJid of chatJids) {
-		for (let page = 0; page < MAX_MESSAGE_PAGES_PER_CHAT; page++) {
-			const messages = (await dispatchGowaChats("getChatMessages", {
-				chat_jid: chatJid,
-				is_from_me: true,
-				start_time: recordedSince,
-				limit: GOWA_PAGE_LIMIT,
-				offset: page * GOWA_PAGE_LIMIT,
-			})) as GowaPaged<GowaOutboundMessage> | undefined;
-			const batch = ((messages?.results?.data ?? []) as GowaOutboundMessage[]).filter(
-				(m) => m && typeof m.id === "string",
-			);
-			outbound.push(...batch);
-			if (batch.length < GOWA_PAGE_LIMIT) break;
-		}
-	}
-	if (outbound.length === 0) return 0;
-
-	const prisma = getPrisma();
-	const ids = outbound.map((m) => m.id);
-	const recorded = await prisma.$queryRawUnsafe<Array<{ external_msg_id: string }>>(
-		`SELECT external_msg_id FROM messaging_logs WHERE external_msg_id = ANY($1::text[])`,
-		ids,
-	);
-	const recordedIds = new Set(recorded.map((r) => r.external_msg_id));
-	const missing = diffOutboundSends(outbound, recordedIds, new Date(), RECONCILE_SETTLE_MS);
-	if (missing.length === 0) return 0;
-
-	for (const miss of missing) {
-		const row = buildBackfillRow(miss);
-		// createMany + skipDuplicates: the table's unique (agent_id,
-		// external_chat_id, external_msg_id) makes a double-backfill (a sweep
-		// racing the dispatch-time recorder) a no-op instead of a crash.
-		await prisma.messaging_logs.createMany({
-			skipDuplicates: true,
-			data: {
-				id: row.id,
-				organisation_id: "",
-				platform: row.platform,
-				agent_id: "",
-				external_chat_id: row.external_chat_id,
-				user_phone: row.user_phone,
-				external_msg_id: row.external_msg_id,
-				direction: row.direction,
-				event_type: row.event_type,
-				content: row.content,
-				payload: {
-					...row.payload,
-					send_at: row.timestampIso,
-					reconciled_at: new Date().toISOString(),
-				},
-				created_at: new Date(row.timestampIso),
-			},
-		});
-	}
-
-	recordEvent({
-		kind: "messaging.send.reconciled",
-		payload: {
-			backfilledCount: missing.length,
-			baseline: recordedSince,
-			sample: missing.slice(0, DEFAULT_SAMPLE_LIMIT).map((m) => ({
-				external_msg_id: m.id,
-				chat_id: m.chatJid,
-				content: m.content?.slice(0, 120) ?? null,
-				sent_at: m.timestamp,
-			})),
-		},
-	});
-	log.info(
-		`[messaging-send-recording-watch] reconcile: ${missing.length} unrecorded outbound send(s) backfilled from GOWA truth`,
-	);
-	return missing.length;
-}
-
-pgBossHandlerRegistry.register(
-	"@teamscala/service-boot:messaging-send-recording-watch",
-	messagingSendRecordingWatch,
-);

package/src/handlers/messaging-send-sweep-selection.test.ts

@@ -1,47 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { describe, expect, test } from "bun:test";
-import {
-	selectChatsToSweep,
-	type GowaChatSummary,
-} from "./messaging-send-sweep-selection.ts";
-
-describe("selectChatsToSweep", () => {
-	test("keeps chats at/after the horizon and lets paging stop once a page is older", () => {
-		const chats: GowaChatSummary[] = [
-			{ jid: "a@s.whatsapp.net", last_message_time: "2026-08-26T02:14:00Z" },
-			{ jid: "b@s.whatsapp.net", last_message_time: "2026-08-25T16:14:13Z" },
-			{ jid: "old@s.whatsapp.net", last_message_time: "2026-08-01T00:00:00Z" },
-		];
-		const { toSweep, mayStopPaging } = selectChatsToSweep(
-			chats,
-			Date.parse("2026-08-25T10:19:00Z"),
-		);
-		expect(toSweep).toEqual(["a@s.whatsapp.net", "b@s.whatsapp.net"]);
-		expect(mayStopPaging).toBe(true);
-	});
-
-	test("keeps paging while the page's newest chats still qualify", () => {
-		const chats: GowaChatSummary[] = [
-			{ jid: "a@s.whatsapp.net", last_message_time: "2026-08-26T02:14:00Z" },
-		];
-		const { mayStopPaging } = selectChatsToSweep(chats, Date.parse("2026-08-25T10:19:00Z"));
-		expect(mayStopPaging).toBe(false);
-	});
-
-	test("a chat with no last_message_time never qualifies and stops paging", () => {
-		const { toSweep, mayStopPaging } = selectChatsToSweep(
-			[{ jid: "silent@s.whatsapp.net", last_message_time: null }],
-			0,
-		);
-		expect(toSweep).toEqual([]);
-		expect(mayStopPaging).toBe(true);
-	});
-});

package/src/handlers/messaging-send-sweep-selection.ts

@@ -1,35 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Chat-page selection for the messaging-send reconcile sweep: which paged
- * GOWA chats (newest-first) still have activity at/after the baseline, and
- * whether paging may stop. Pure and dependency-free, the same shape as the
- * sibling *-logic units.
- */
-
-/** One chat from GOWA `listChats` — only the sweep-relevant fields. */
-export interface GowaChatSummary {
-	jid: string;
-	last_message_time: string | null;
-}
-
-/** Chats worth sweeping: those with activity at/after the horizon. */
-export function selectChatsToSweep(
-	chats: GowaChatSummary[],
-	horizonMs: number,
-): { toSweep: string[]; mayStopPaging: boolean } {
-	const toSweep: string[] = [];
-	for (const chat of chats) {
-		const at = Date.parse(chat.last_message_time ?? "");
-		if (!Number.isNaN(at) && at >= horizonMs) toSweep.push(chat.jid);
-	}
-	const last = chats[chats.length - 1];
-	// A null/unparseable last_message_time means the chat never messaged (or
-	// GOWA answered something unexpected) — it cannot hide an outbound send, so
-	// it reads as "older than the horizon" for the paging decision.
-	const lastAt = Date.parse(last?.last_message_time ?? "");
-	const mayStopPaging = chats.length === 0 || Number.isNaN(lastAt) || lastAt < horizonMs;
-	return { toSweep, mayStopPaging };
-}