birdclaw 0.5.0 → 0.6.0

package/src/lib/queries.ts

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
+import { Effect } from "effect";
 import type { Database } from "./sqlite";
-import { findArchives } from "./archive-finder";
+import { findArchivesEffect } from "./archive-finder";
 import { getDb, getNativeDb } from "./db";
+import { runEffectPromise, tryPromise } from "./effect-runtime";
 import { fetchProfileAffiliations } from "./profile-affiliations";
 import { displayUrlForLink, enrichFallbackUrlEntities } from "./tweet-render";
 import type {
@@ -23,16 +25,92 @@ import type {
 	TweetUrlEntity,
 } from "./types";
 import {
-	dmViaXurl,
-	getTransportStatus,
-	postViaXurl,
-	replyViaXurl,
+	dmViaXurlEffect,
+	getTransportStatusEffect,
+	lookupAuthenticatedUserFresh,
+	postViaXurlEffect,
+	replyViaXurlEffect,
 } from "./xurl";
 
+function toError(error: unknown) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+function trySync<T>(try_: () => T) {
+	return Effect.try({
+		try: try_,
+		catch: toError,
+	});
+}
+
+function e2eFakeLiveWritesEnabled() {
+	return (
+		process.env.BIRDCLAW_E2E === "1" &&
+		process.env.BIRDCLAW_E2E_FAKE_LIVE_WRITES === "1"
+	);
+}
+
+function liveWritesDisabled() {
+	return process.env.BIRDCLAW_DISABLE_LIVE_WRITES === "1";
+}
+
+function verifySelectedXurlAccountEffect(accountId: string) {
+	return Effect.gen(function* () {
+		if (liveWritesDisabled()) return;
+		if (e2eFakeLiveWritesEnabled()) return;
+		const db = yield* trySync(() => getNativeDb());
+		const account = yield* trySync(
+			() =>
+				db
+					.prepare("select handle, external_user_id from accounts where id = ?")
+					.get(accountId) as
+					| { handle: string; external_user_id: string | null }
+					| undefined,
+		);
+		if (!account) {
+			return yield* Effect.fail(new Error(`Unknown account: ${accountId}`));
+		}
+		const authenticated = yield* tryPromise(() =>
+			lookupAuthenticatedUserFresh(),
+		);
+		const authenticatedId =
+			typeof authenticated?.id === "string" ? authenticated.id : "";
+		const authenticatedHandle =
+			typeof authenticated?.username === "string"
+				? authenticated.username.replace(/^@/, "")
+				: "";
+		const expectedHandle = account.handle.replace(/^@/, "");
+		if (
+			(account.external_user_id &&
+				account.external_user_id !== authenticatedId) ||
+			(!account.external_user_id &&
+				(!authenticatedHandle ||
+					authenticatedHandle.toLowerCase() !== expectedHandle.toLowerCase()))
+		) {
+			return yield* Effect.fail(
+				new Error(
+					`xurl is authenticated as @${authenticatedHandle || authenticatedId}, not @${expectedHandle}`,
+				),
+			);
+		}
+	});
+}
+
 function getInfluenceScore(followersCount: number) {
 	return Math.round(Math.log10(followersCount + 10) * 24);
 }
 
+function getMinFollowersForInfluenceScore(score: number) {
+	if (!Number.isFinite(score)) return undefined;
+	return Math.max(0, Math.ceil(10 ** ((score - 0.5) / 24) - 10));
+}
+
+function getMaxFollowersForInfluenceScore(score: number) {
+	if (!Number.isFinite(score)) return undefined;
+	if (score < getInfluenceScore(0)) return -1;
+	return Math.max(0, Math.ceil(10 ** ((score + 0.5) / 24) - 10) - 1);
+}
+
 function getInfluenceLabel(score: number) {
 	if (score >= 150) return "very high";
 	if (score >= 120) return "high";
@@ -82,6 +160,124 @@ function parseJsonField<T>(value: unknown, fallback: T): T {
 	}
 }
 
+function normalizeProfileHandle(handle: string) {
+	return handle.replace(/^@/, "").toLowerCase();
+}
+
+function avatarHueForHandle(handle: string) {
+	let hash = 0;
+	for (const character of handle) {
+		hash = (hash * 31 + character.charCodeAt(0)) % 360;
+	}
+	return hash;
+}
+
+function fallbackProfileForHandle(handle: string): ProfileRecord {
+	const normalized = normalizeProfileHandle(handle);
+	return {
+		id: `profile_handle_${normalized}`,
+		handle: normalized,
+		displayName: `@${normalized}`,
+		bio: "",
+		followersCount: 0,
+		avatarHue: avatarHueForHandle(normalized),
+		createdAt: new Date(0).toISOString(),
+	};
+}
+
+type ProfileByHandleCache = Map<string, ProfileRecord | null>;
+
+function getProfileByHandle(
+	db: Database,
+	cache: ProfileByHandleCache,
+	handle: string,
+	profiles: Record<string, ProfileRecord> = {},
+) {
+	const normalized = normalizeProfileHandle(handle);
+	const inlineProfile = Object.values(profiles).find(
+		(profile) => normalizeProfileHandle(profile.handle) === normalized,
+	);
+	if (inlineProfile) {
+		return inlineProfile;
+	}
+
+	if (cache.has(normalized)) {
+		return cache.get(normalized) ?? fallbackProfileForHandle(normalized);
+	}
+
+	const row = db
+		.prepare(
+			`
+      select *
+      from profiles
+      where lower(handle) = lower(?)
+      limit 1
+      `,
+		)
+		.get(normalized) as Record<string, unknown> | undefined;
+	const profile = row ? toProfile(row) : null;
+	cache.set(normalized, profile);
+	return profile ?? fallbackProfileForHandle(normalized);
+}
+
+function spansOverlap(
+	leftStart: number,
+	leftEnd: number,
+	rightStart: number,
+	rightEnd: number,
+) {
+	return leftStart < rightEnd && rightStart < leftEnd;
+}
+
+function enrichFallbackMentionEntities(
+	text: string,
+	entities: TweetEntities,
+	resolveProfileByHandle: (handle: string) => ProfileRecord,
+): TweetEntities {
+	const existingMentions = entities.mentions ?? [];
+	const occupied = [
+		...existingMentions,
+		...(entities.urls ?? []),
+		...(entities.hashtags ?? []),
+	].map((entry) => ({ start: entry.start, end: entry.end }));
+	const fallbackMentions = [];
+	const mentionPattern = /(^|[^\w@])@([A-Za-z0-9_]{1,15})/g;
+
+	for (const match of text.matchAll(mentionPattern)) {
+		const prefix = match[1] ?? "";
+		const username = match[2];
+		if (!username) continue;
+		const start = (match.index ?? 0) + prefix.length;
+		const end = start + username.length + 1;
+		if (
+			occupied.some((entry) => spansOverlap(start, end, entry.start, entry.end))
+		) {
+			continue;
+		}
+
+		const profile = resolveProfileByHandle(username);
+		fallbackMentions.push({
+			username,
+			id: profile.id,
+			start,
+			end,
+			profile,
+		});
+		occupied.push({ start, end });
+	}
+
+	if (fallbackMentions.length === 0) {
+		return entities;
+	}
+
+	return {
+		...entities,
+		mentions: [...existingMentions, ...fallbackMentions].sort(
+			(left, right) => left.start - right.start,
+		),
+	};
+}
+
 function toFtsSearchQuery(value: string) {
 	const terms = value.match(/[\p{L}\p{N}_]+/gu) ?? [];
 	return terms
@@ -94,13 +290,17 @@ function toFtsSearchQuery(value: string) {
 function enrichEntities(
 	entities: TweetEntities,
 	profiles: Record<string, ProfileRecord>,
+	resolveProfileByHandle?: (handle: string) => ProfileRecord,
 ): TweetEntities {
 	const mentions = entities.mentions?.map((mention) => {
 		const profile =
 			(mention.id ? profiles[mention.id] : undefined) ??
 			Object.values(profiles).find(
-				(candidate) => candidate.handle === mention.username,
-			);
+				(candidate) =>
+					normalizeProfileHandle(candidate.handle) ===
+					normalizeProfileHandle(mention.username),
+			) ??
+			resolveProfileByHandle?.(mention.username);
 		return profile ? { ...mention, profile } : mention;
 	});
 
@@ -171,12 +371,16 @@ function enrichTimelineEntities(
 	text: string,
 	entities: TweetEntities,
 	profiles: Record<string, ProfileRecord>,
+	resolveProfileByHandle?: (handle: string) => ProfileRecord,
 ): TweetEntities {
-	return enrichFallbackUrlEntities(
+	const withUrls = enrichFallbackUrlEntities(
 		text,
-		enrichEntities(entities, profiles),
+		enrichEntities(entities, profiles, resolveProfileByHandle),
 		(rawUrl) => getUrlExpansion(db, urlExpansionCache, rawUrl),
 	);
+	return resolveProfileByHandle
+		? enrichFallbackMentionEntities(text, withUrls, resolveProfileByHandle)
+		: withUrls;
 }
 
 function buildEmbeddedTweet(
@@ -184,6 +388,7 @@ function buildEmbeddedTweet(
 	urlExpansionCache: UrlExpansionCache,
 	row: Record<string, unknown>,
 	prefix: string,
+	resolveProfileByHandle?: (handle: string) => ProfileRecord,
 ): EmbeddedTweet | null {
 	if (!row[`${prefix}id`]) {
 		return null;
@@ -210,6 +415,21 @@ function buildEmbeddedTweet(
 			typeof row[`${prefix}reply_to_id`] === "string"
 				? String(row[`${prefix}reply_to_id`])
 				: null,
+		...(row[`${prefix}is_replied`] === undefined
+			? {}
+			: { isReplied: Boolean(row[`${prefix}is_replied`]) }),
+		...(row[`${prefix}like_count`] === undefined
+			? {}
+			: { likeCount: Number(row[`${prefix}like_count`]) }),
+		...(row[`${prefix}media_count`] === undefined
+			? {}
+			: { mediaCount: Number(row[`${prefix}media_count`]) }),
+		...(row[`${prefix}bookmarked`] === undefined
+			? {}
+			: { bookmarked: Boolean(row[`${prefix}bookmarked`]) }),
+		...(row[`${prefix}liked`] === undefined
+			? {}
+			: { liked: Boolean(row[`${prefix}liked`]) }),
 		author,
 		entities: enrichTimelineEntities(
 			db,
@@ -219,11 +439,113 @@ function buildEmbeddedTweet(
 			{
 				[author.id]: author,
 			},
+			resolveProfileByHandle,
 		),
 		media: parseJsonField<TweetMediaItem[]>(row[`${prefix}media_json`], []),
 	};
 }
 
+function getRetweetedTweetIdFromRaw(rawJson: unknown) {
+	const raw = parseJsonField<Record<string, unknown>>(rawJson, {});
+	const directCandidates = [
+		raw.retweeted_tweet_id,
+		raw.retweetedTweetId,
+		raw.retweetedStatusId,
+		raw.retweeted_status_id_str,
+	];
+	for (const candidate of directCandidates) {
+		if (typeof candidate === "string" && candidate.length > 0) {
+			return candidate;
+		}
+	}
+
+	const nestedCandidates = [raw.retweetedTweet, raw.retweeted_status];
+	for (const nested of nestedCandidates) {
+		if (nested && typeof nested === "object") {
+			const record = nested as Record<string, unknown>;
+			for (const key of ["id", "id_str"]) {
+				if (typeof record[key] === "string" && record[key].length > 0) {
+					return record[key];
+				}
+			}
+		}
+	}
+
+	const references = [raw.referenced_tweets, raw.referencedTweets].find(
+		(value): value is unknown[] => Array.isArray(value),
+	);
+	for (const reference of references ?? []) {
+		if (!reference || typeof reference !== "object") continue;
+		const record = reference as Record<string, unknown>;
+		if (record.type === "retweeted" && typeof record.id === "string") {
+			return record.id;
+		}
+	}
+
+	return null;
+}
+
+function parseManualRetweet(text: string) {
+	const match = text.match(/^RT\s+@([A-Za-z0-9_]{1,15}):\s*([\s\S]+)$/);
+	if (!match?.[1] || !match[2]) {
+		return null;
+	}
+	return {
+		handle: match[1],
+		text: match[2].trim(),
+	};
+}
+
+function buildRetweetedTweet(
+	db: Database,
+	urlExpansionCache: UrlExpansionCache,
+	row: Record<string, unknown>,
+	resolveProfileByHandle: (handle: string) => ProfileRecord,
+) {
+	const retweetedId = getRetweetedTweetIdFromRaw(row.edge_raw_json);
+	const accountId = String(row.account_id);
+	if (retweetedId) {
+		const tweet = getTweetById(
+			db,
+			urlExpansionCache,
+			retweetedId,
+			resolveProfileByHandle,
+			accountId,
+		);
+		if (tweet) {
+			return tweet;
+		}
+	}
+
+	const manualRetweet = parseManualRetweet(String(row.text ?? ""));
+	if (!manualRetweet) {
+		return null;
+	}
+
+	const author = resolveProfileByHandle(manualRetweet.handle);
+	return {
+		id: `${String(row.id)}:retweeted`,
+		text: manualRetweet.text,
+		createdAt: String(row.created_at ?? new Date(0).toISOString()),
+		replyToId: null,
+		isReplied: Boolean(row.is_replied),
+		likeCount: Number(row.like_count ?? 0),
+		mediaCount: 0,
+		bookmarked: Boolean(row.bookmarked),
+		liked: Boolean(row.liked),
+		author,
+		entities: enrichTimelineEntities(
+			db,
+			urlExpansionCache,
+			manualRetweet.text,
+			{},
+			{ [author.id]: author },
+			resolveProfileByHandle,
+		),
+		media: [],
+	};
+}
+
 function buildReplyClause(replyFilter: ReplyFilter) {
 	if (replyFilter === "replied") {
 		return " and is_replied = 1";
@@ -321,12 +643,18 @@ function countTimelineEdges(db: Database, kind: "home" | "mention") {
 	const row = db
 		.prepare(
 			`
-      with timeline_edges as (
-        select account_id, tweet_id, kind
-        from tweet_account_edges
-        where kind = ?
+      select count(distinct tweet_id) as count
+      from (
+        select edge.tweet_id
+        from tweet_account_edges edge
+        where edge.kind = ?
+          and exists (
+            select 1
+            from tweets t
+            where t.id = edge.tweet_id
+          )
         union all
-        select legacy.account_id, legacy.id as tweet_id, legacy.kind
+        select legacy.id as tweet_id
         from tweets legacy
         where legacy.kind = ?
           and not exists (
@@ -337,61 +665,118 @@ function countTimelineEdges(db: Database, kind: "home" | "mention") {
               and edge.kind = legacy.kind
           )
       )
-      select count(*) as count
-      from timeline_edges e
-      join tweets t on t.id = e.tweet_id
-      where e.kind = ?
       `,
 		)
-		.get(kind, kind, kind) as { count: number | bigint } | undefined;
+		.get(kind, kind) as { count: number | bigint } | undefined;
 	return Number(row?.count ?? 0);
 }
 
-export async function getQueryEnvelope(): Promise<QueryEnvelope> {
-	const db = getDb();
-	const nativeDb = getNativeDb();
-	const homeCount = countTimelineEdges(nativeDb, "home");
-	const mentionCount = countTimelineEdges(nativeDb, "mention");
-	const counts = await Promise.all([
-		db
-			.selectFrom("dm_conversations")
-			.select((eb) => eb.fn.countAll().as("count"))
-			.executeTakeFirstOrThrow(),
-		db
-			.selectFrom("dm_conversations")
-			.select((eb) => eb.fn.countAll().as("count"))
-			.where("needs_reply", "=", 1)
-			.executeTakeFirstOrThrow(),
-		db
-			.selectFrom("accounts")
-			.selectAll()
-			.orderBy("is_default", "desc")
-			.orderBy("name", "asc")
-			.execute(),
-		findArchives(),
-		getTransportStatus(),
-	]);
+const RECENT_TIMELINE_EDGE_CANDIDATES = 5000;
 
-	return {
-		stats: {
-			home: homeCount,
-			mentions: mentionCount,
-			dms: Number(counts[0].count),
-			needsReply: Number(counts[1].count),
-			inbox: mentionCount + Number(counts[1].count),
-		},
-		accounts: counts[2].map((row) => ({
-			id: row.id,
-			name: row.name,
-			handle: row.handle,
-			externalUserId: row.external_user_id,
-			transport: row.transport,
-			isDefault: row.is_default,
-			createdAt: row.created_at,
-		})) satisfies AccountRecord[],
-		archives: counts[3],
-		transport: counts[4],
-	};
+function getAccountProfileMeta(
+	db: Database,
+	account: { handle: string; external_user_id: string | null },
+) {
+	const handle = account.handle.replace(/^@/, "");
+	const externalProfileId = account.external_user_id
+		? `profile_user_${account.external_user_id}`
+		: "";
+	return db
+		.prepare(
+			`
+      select id, avatar_hue, avatar_url
+      from profiles
+      where id = ?
+         or lower(handle) = lower(?)
+      order by case
+        when id = 'profile_me' then 0
+        when id = ? then 1
+        else 2
+      end
+      limit 1
+    `,
+		)
+		.get(externalProfileId, handle, externalProfileId) as
+		| { id: string; avatar_hue: number; avatar_url: string | null }
+		| undefined;
+}
+
+export function getQueryEnvelopeEffect(): Effect.Effect<
+	QueryEnvelope,
+	unknown
+> {
+	return Effect.gen(function* () {
+		const db = yield* trySync(() => getDb());
+		const nativeDb = yield* trySync(() => getNativeDb());
+		const homeCount = yield* trySync(() =>
+			countTimelineEdges(nativeDb, "home"),
+		);
+		const mentionCount = yield* trySync(() =>
+			countTimelineEdges(nativeDb, "mention"),
+		);
+		const counts = yield* Effect.all({
+			dms: tryPromise(() =>
+				db
+					.selectFrom("dm_conversations")
+					.select((eb) => eb.fn.countAll().as("count"))
+					.executeTakeFirstOrThrow(),
+			),
+			needsReply: tryPromise(() =>
+				db
+					.selectFrom("dm_conversations")
+					.select((eb) => eb.fn.countAll().as("count"))
+					.where("needs_reply", "=", 1)
+					.executeTakeFirstOrThrow(),
+			),
+			accounts: tryPromise(() =>
+				db
+					.selectFrom("accounts")
+					.selectAll()
+					.orderBy("is_default", "desc")
+					.orderBy("name", "asc")
+					.execute(),
+			),
+			archives: findArchivesEffect(),
+			transport: getTransportStatusEffect(),
+		});
+
+		return {
+			stats: {
+				home: homeCount,
+				mentions: mentionCount,
+				dms: Number(counts.dms.count),
+				needsReply: Number(counts.needsReply.count),
+				inbox: mentionCount + Number(counts.needsReply.count),
+			},
+			accounts: counts.accounts.map((row) => {
+				const profile = getAccountProfileMeta(nativeDb, row);
+				return {
+					id: row.id,
+					name: row.name,
+					handle: row.handle,
+					externalUserId: row.external_user_id,
+					...(profile
+						? {
+								profileId: profile.id,
+								avatarHue: Number(profile.avatar_hue),
+								...(profile.avatar_url
+									? { avatarUrl: profile.avatar_url }
+									: {}),
+							}
+						: {}),
+					transport: row.transport,
+					isDefault: row.is_default,
+					createdAt: row.created_at,
+				};
+			}) satisfies AccountRecord[],
+			archives: counts.archives,
+			transport: counts.transport,
+		};
+	});
+}
+
+export function getQueryEnvelope(): Promise<QueryEnvelope> {
+	return runEffectPromise(getQueryEnvelopeEffect());
 }
 
 export function listTimelineItems({
@@ -414,13 +799,14 @@ export function listTimelineItems({
 	const params: Array<string | number> = [];
 	const normalizedLowQualityThreshold =
 		normalizeLowQualityThreshold(lowQualityThreshold);
+	const shouldDedupeAcrossAccounts = !account || account === "all";
 	let timelineEdgesCte = `
       with timeline_edges as (
-        select account_id, tweet_id, kind
+        select account_id, tweet_id, kind, raw_json
         from tweet_account_edges
         where kind = ?
         union all
-        select legacy.account_id, legacy.id as tweet_id, legacy.kind
+        select legacy.account_id, legacy.id as tweet_id, legacy.kind, '{}' as raw_json
         from tweets legacy
         where legacy.kind = ?
           and not exists (
@@ -432,15 +818,28 @@ export function listTimelineItems({
           )
       )
     `;
+	const unwindowedTimelineEdgesCte = timelineEdgesCte;
+	let usedRecentEdgeWindow = false;
 	let join = "";
 	let where = "where t.kind = ?";
 	let searchSnippetSelect = "";
 
+	const canUseRecentEdgeWindow =
+		!likedOnly &&
+		!bookmarkedOnly &&
+		!account &&
+		!search?.trim() &&
+		replyFilter === "all" &&
+		!since?.trim() &&
+		!until?.trim() &&
+		includeReplies &&
+		qualityFilter === "all";
+
 	if (likedOnly || bookmarkedOnly) {
 		if (likedOnly && bookmarkedOnly) {
 			timelineEdgesCte = `
         with timeline_edges as (
-          select likes.account_id, likes.tweet_id, 'home' as kind
+          select likes.account_id, likes.tweet_id, 'home' as kind, likes.raw_json
           from tweet_collections likes
           join tweet_collections bookmarks
             on bookmarks.account_id = likes.account_id
@@ -448,7 +847,7 @@ export function listTimelineItems({
             and bookmarks.kind = 'bookmarks'
           where likes.kind = 'likes'
           union all
-          select legacy.account_id, legacy.id as tweet_id, 'home' as kind
+          select legacy.account_id, legacy.id as tweet_id, 'home' as kind, '{}' as raw_json
           from tweets legacy
           where legacy.liked = 1
             and legacy.bookmarked = 1
@@ -466,11 +865,11 @@ export function listTimelineItems({
 			const legacyColumn = likedOnly ? "liked" : "bookmarked";
 			timelineEdgesCte = `
         with timeline_edges as (
-          select account_id, tweet_id, 'home' as kind
+          select account_id, tweet_id, 'home' as kind, raw_json
           from tweet_collections
           where kind = ?
           union all
-          select legacy.account_id, legacy.id as tweet_id, 'home' as kind
+          select legacy.account_id, legacy.id as tweet_id, 'home' as kind, '{}' as raw_json
           from tweets legacy
           where legacy.${legacyColumn} = 1
             and not exists (
@@ -481,10 +880,49 @@ export function listTimelineItems({
                 and collection.kind = ?
             )
         )
-      `;
+			`;
 			params.push(collectionKind, collectionKind);
 		}
 		where = "where 1 = 1";
+	} else if (canUseRecentEdgeWindow) {
+		usedRecentEdgeWindow = true;
+		timelineEdgesCte = `
+      with timeline_edges as (
+        select account_id, tweet_id, kind, raw_json
+        from tweet_account_edges
+        where kind = ?
+          and tweet_id in (
+            select id
+            from tweets
+            order by created_at desc
+            limit ?
+          )
+        union all
+        select legacy.account_id, legacy.id as tweet_id, legacy.kind, '{}' as raw_json
+        from tweets legacy
+        where legacy.kind = ?
+          and legacy.id in (
+            select id
+            from tweets
+            order by created_at desc
+            limit ?
+          )
+          and not exists (
+            select 1
+            from tweet_account_edges edge
+            where edge.account_id = legacy.account_id
+              and edge.tweet_id = legacy.id
+              and edge.kind = legacy.kind
+          )
+      )
+    `;
+		const candidateLimit = Math.max(
+			RECENT_TIMELINE_EDGE_CANDIDATES,
+			limit * 50,
+		);
+		params.push(kind, candidateLimit, kind, candidateLimit);
+		where = "where e.kind = ?";
+		params.push(kind);
 	} else {
 		params.push(kind, kind);
 		where = "where e.kind = ?";
@@ -496,6 +934,20 @@ export function listTimelineItems({
 		params.push(account);
 	}
 
+	if (shouldDedupeAcrossAccounts) {
+		where += `
+      and e.account_id = (
+        select e2.account_id
+        from timeline_edges e2
+        join accounts a2 on a2.id = e2.account_id
+        where e2.tweet_id = e.tweet_id
+          and e2.kind = e.kind
+        order by a2.is_default desc, e2.account_id asc
+        limit 1
+      )
+    `;
+	}
+
 	where += buildReplyClause(replyFilter).replaceAll(
 		"is_replied",
 		"t.is_replied",
@@ -532,15 +984,14 @@ export function listTimelineItems({
 
 	params.push(limit);
 
-	const rows = db
-		.prepare(
-			`
-      ${timelineEdgesCte}
+	const buildTimelineSelectSql = (timelineEdgesSql: string) => `
+      ${timelineEdgesSql}
       select
         t.id,
         e.account_id,
         a.handle as account_handle,
         e.kind,
+        e.raw_json as edge_raw_json,
         t.text,
         t.created_at,
         t.reply_to_id,
@@ -626,11 +1077,20 @@ export function listTimelineItems({
       ${where}
       order by t.created_at desc
       limit ?
-      `,
-		)
+      `;
+
+	let rows = db
+		.prepare(buildTimelineSelectSql(timelineEdgesCte))
 		.all(...params) as Array<Record<string, unknown>>;
 
+	if (usedRecentEdgeWindow && rows.length < limit) {
+		rows = db
+			.prepare(buildTimelineSelectSql(unwindowedTimelineEdgesCte))
+			.all(kind, kind, kind, limit) as Array<Record<string, unknown>>;
+	}
+
 	const urlExpansionCache: UrlExpansionCache = new Map();
+	const profileByHandleCache: ProfileByHandleCache = new Map();
 	return rows.map((row) => {
 		const author = {
 			id: String(row.profile_id),
@@ -644,45 +1104,49 @@ export function listTimelineItems({
 				typeof row.avatar_url === "string" ? String(row.avatar_url) : undefined,
 			createdAt: String(row.profile_created_at),
 		};
+		const rowProfiles: Record<string, ProfileRecord> = {
+			[author.id]: author,
+			...(row.reply_profile_id
+				? {
+						[String(row.reply_profile_id)]: toProfile({
+							id: row.reply_profile_id,
+							handle: row.reply_handle,
+							display_name: row.reply_display_name,
+							bio: row.reply_bio,
+							followers_count: row.reply_followers_count,
+							following_count: row.reply_following_count,
+							avatar_hue: row.reply_avatar_hue,
+							avatar_url: row.reply_avatar_url,
+							created_at: row.reply_profile_created_at,
+						}),
+					}
+				: {}),
+			...(row.quoted_profile_id
+				? {
+						[String(row.quoted_profile_id)]: toProfile({
+							id: row.quoted_profile_id,
+							handle: row.quoted_handle,
+							display_name: row.quoted_display_name,
+							bio: row.quoted_bio,
+							followers_count: row.quoted_followers_count,
+							following_count: row.quoted_following_count,
+							avatar_hue: row.quoted_avatar_hue,
+							avatar_url: row.quoted_avatar_url,
+							created_at: row.quoted_profile_created_at,
+						}),
+					}
+				: {}),
+		};
+		const resolveProfileByHandle = (handle: string) =>
+			getProfileByHandle(db, profileByHandleCache, handle, rowProfiles);
 		const text = String(row.text);
 		const entities = enrichTimelineEntities(
 			db,
 			urlExpansionCache,
 			text,
 			parseJsonField<TweetEntities>(row.entities_json, {}),
-			{
-				[author.id]: author,
-				...(row.reply_profile_id
-					? {
-							[String(row.reply_profile_id)]: toProfile({
-								id: row.reply_profile_id,
-								handle: row.reply_handle,
-								display_name: row.reply_display_name,
-								bio: row.reply_bio,
-								followers_count: row.reply_followers_count,
-								following_count: row.reply_following_count,
-								avatar_hue: row.reply_avatar_hue,
-								avatar_url: row.reply_avatar_url,
-								created_at: row.reply_profile_created_at,
-							}),
-						}
-					: {}),
-				...(row.quoted_profile_id
-					? {
-							[String(row.quoted_profile_id)]: toProfile({
-								id: row.quoted_profile_id,
-								handle: row.quoted_handle,
-								display_name: row.quoted_display_name,
-								bio: row.quoted_bio,
-								followers_count: row.quoted_followers_count,
-								following_count: row.quoted_following_count,
-								avatar_hue: row.quoted_avatar_hue,
-								avatar_url: row.quoted_avatar_url,
-								created_at: row.quoted_profile_created_at,
-							}),
-						}
-					: {}),
-			},
+			rowProfiles,
+			resolveProfileByHandle,
 		);
 		const item = {
 			id: String(row.id),
@@ -704,8 +1168,26 @@ export function listTimelineItems({
 			author,
 			entities,
 			media: parseJsonField<TweetMediaItem[]>(row.media_json, []),
-			replyToTweet: buildEmbeddedTweet(db, urlExpansionCache, row, "reply_"),
-			quotedTweet: buildEmbeddedTweet(db, urlExpansionCache, row, "quoted_"),
+			replyToTweet: buildEmbeddedTweet(
+				db,
+				urlExpansionCache,
+				row,
+				"reply_",
+				resolveProfileByHandle,
+			),
+			quotedTweet: buildEmbeddedTweet(
+				db,
+				urlExpansionCache,
+				row,
+				"quoted_",
+				resolveProfileByHandle,
+			),
+			retweetedTweet: buildRetweetedTweet(
+				db,
+				urlExpansionCache,
+				row,
+				resolveProfileByHandle,
+			),
 		};
 		return includeQualityReason
 			? {
@@ -719,12 +1201,42 @@ export function listTimelineItems({
 	});
 }
 
-const conversationTweetSelect = `
+function conversationTweetSelect(accountId?: string) {
+	const collectionStateSelect = accountId
+		? `
+    case
+      when exists (
+        select 1 from tweet_collections collection
+        where collection.account_id = ?
+          and collection.tweet_id = t.id
+          and collection.kind = 'bookmarks'
+      ) then 1
+      when t.account_id = ? and t.bookmarked = 1 then 1
+      else 0
+    end as bookmarked,
+    case
+      when exists (
+        select 1 from tweet_collections collection
+        where collection.account_id = ?
+          and collection.tweet_id = t.id
+          and collection.kind = 'likes'
+      ) then 1
+      when t.account_id = ? and t.liked = 1 then 1
+      else 0
+    end as liked,`
+		: `
+    t.bookmarked,
+    t.liked,`;
+	return `
   select
     t.id,
     t.text,
     t.created_at,
     t.reply_to_id,
+    t.is_replied,
+    t.like_count,
+    t.media_count,
+    ${collectionStateSelect}
     t.entities_json,
     t.media_json,
     p.id as profile_id,
@@ -739,17 +1251,29 @@ const conversationTweetSelect = `
   from tweets t
   join profiles p on p.id = t.author_profile_id
 `;
+}
 
 function getTweetById(
 	db: Database,
 	urlExpansionCache: UrlExpansionCache,
 	tweetId: string,
+	resolveProfileByHandle?: (handle: string) => ProfileRecord,
+	accountId?: string,
 ): EmbeddedTweet | null {
+	const stateParams = accountId
+		? [accountId, accountId, accountId, accountId]
+		: [];
 	const row = db
-		.prepare(`${conversationTweetSelect} where t.id = ?`)
-		.get(tweetId) as Record<string, unknown> | undefined;
+		.prepare(`${conversationTweetSelect(accountId)} where t.id = ?`)
+		.get(...stateParams, tweetId) as Record<string, unknown> | undefined;
 	if (!row) return null;
-	return buildEmbeddedTweet(db, urlExpansionCache, row, "");
+	return buildEmbeddedTweet(
+		db,
+		urlExpansionCache,
+		row,
+		"",
+		resolveProfileByHandle,
+	);
 }
 
 function listTweetDescendants(
@@ -757,6 +1281,7 @@ function listTweetDescendants(
 	urlExpansionCache: UrlExpansionCache,
 	rootId: string,
 	limit: number,
+	resolveProfileByHandle?: (handle: string) => ProfileRecord,
 ) {
 	if (limit <= 0) return [];
 	const rows = db
@@ -772,7 +1297,7 @@ function listTweetDescendants(
         join branch on child.reply_to_id = branch.id
         where branch.depth < 8
       )
-      ${conversationTweetSelect}
+      ${conversationTweetSelect()}
       join branch on branch.id = t.id
       where t.id != ?
       order by t.created_at asc
@@ -782,7 +1307,15 @@ function listTweetDescendants(
 		.all(rootId, rootId, limit) as Array<Record<string, unknown>>;
 
 	return rows
-		.map((row) => buildEmbeddedTweet(db, urlExpansionCache, row, ""))
+		.map((row) =>
+			buildEmbeddedTweet(
+				db,
+				urlExpansionCache,
+				row,
+				"",
+				resolveProfileByHandle,
+			),
+		)
 		.filter((tweet): tweet is EmbeddedTweet => Boolean(tweet));
 }
 
@@ -805,13 +1338,26 @@ export function getTweetConversation(
 ): TweetConversationResponse | null {
 	const db = getNativeDb();
 	const urlExpansionCache: UrlExpansionCache = new Map();
-	const anchor = getTweetById(db, urlExpansionCache, tweetId);
+	const profileByHandleCache: ProfileByHandleCache = new Map();
+	const resolveProfileByHandle = (handle: string) =>
+		getProfileByHandle(db, profileByHandleCache, handle);
+	const anchor = getTweetById(
+		db,
+		urlExpansionCache,
+		tweetId,
+		resolveProfileByHandle,
+	);
 	if (!anchor) return null;
 
 	const ancestors: EmbeddedTweet[] = [];
 	let current = anchor;
 	for (let depth = 0; depth < 12 && current.replyToId; depth += 1) {
-		const parent = getTweetById(db, urlExpansionCache, current.replyToId);
+		const parent = getTweetById(
+			db,
+			urlExpansionCache,
+			current.replyToId,
+			resolveProfileByHandle,
+		);
 		if (!parent || ancestors.some((tweet) => tweet.id === parent.id)) break;
 		ancestors.push(parent);
 		current = parent;
@@ -832,6 +1378,7 @@ export function getTweetConversation(
 		urlExpansionCache,
 		anchor.id,
 		remainingAfterRequired,
+		resolveProfileByHandle,
 	);
 	appendConversationTweets(items, seen, focusedDescendants, limit);
 
@@ -841,6 +1388,7 @@ export function getTweetConversation(
 			urlExpansionCache,
 			root.id,
 			limit,
+			resolveProfileByHandle,
 		);
 		appendConversationTweets(items, seen, ambientDescendants, limit);
 	}
@@ -856,9 +1404,12 @@ export function getTweetConversation(
 export function listDmConversations({
 	account,
 	conversationIds,
+	inbox = "all",
 	participant,
 	search,
 	replyFilter = "all",
+	since,
+	until,
 	minFollowers,
 	maxFollowers,
 	minInfluenceScore,
@@ -875,6 +1426,31 @@ export function listDmConversations({
 	let where = "where 1 = 1";
 	let searchSnippetSelect = "";
 	const ftsSearch = search?.trim() ? toFtsSearchQuery(search) : "";
+	const influenceMinFollowers =
+		typeof minInfluenceScore === "number"
+			? getMinFollowersForInfluenceScore(minInfluenceScore)
+			: undefined;
+	const influenceMaxFollowers =
+		typeof maxInfluenceScore === "number"
+			? getMaxFollowersForInfluenceScore(maxInfluenceScore)
+			: undefined;
+	const effectiveMinFollowers =
+		typeof minFollowers === "number" ||
+		typeof influenceMinFollowers === "number"
+			? Math.max(minFollowers ?? 0, influenceMinFollowers ?? 0)
+			: undefined;
+	const effectiveMaxFollowers =
+		typeof maxFollowers === "number" ||
+		typeof influenceMaxFollowers === "number"
+			? Math.min(
+					maxFollowers ?? Number.MAX_SAFE_INTEGER,
+					influenceMaxFollowers ?? Number.MAX_SAFE_INTEGER,
+				)
+			: undefined;
+	const orderBy =
+		sort === "followers" || sort === "influence"
+			? "p.followers_count desc, c.last_message_at desc"
+			: "c.last_message_at desc";
 
 	if (account && account !== "all") {
 		where += " and a.id = ?";
@@ -886,6 +1462,12 @@ export function listDmConversations({
 		params.push(...conversationIds);
 	}
 
+	if (inbox === "accepted") {
+		where += " and c.inbox_kind = 'accepted'";
+	} else if (inbox === "requests") {
+		where += " and c.inbox_kind = 'request'";
+	}
+
 	if (participant?.trim()) {
 		where += " and (p.handle like ? or p.display_name like ?)";
 		params.push(`%${participant.trim()}%`, `%${participant.trim()}%`);
@@ -897,14 +1479,23 @@ export function listDmConversations({
 		where += " and c.needs_reply = 1";
 	}
 
-	if (typeof minFollowers === "number") {
+	if (since?.trim()) {
+		where += " and c.last_message_at >= ?";
+		params.push(since);
+	}
+	if (until?.trim()) {
+		where += " and c.last_message_at < ?";
+		params.push(until);
+	}
+
+	if (typeof effectiveMinFollowers === "number") {
 		where += " and p.followers_count >= ?";
-		params.push(minFollowers);
+		params.push(effectiveMinFollowers);
 	}
 
-	if (typeof maxFollowers === "number") {
+	if (typeof effectiveMaxFollowers === "number") {
 		where += " and p.followers_count <= ?";
-		params.push(maxFollowers);
+		params.push(effectiveMaxFollowers);
 	}
 
 	if (ftsSearch) {
@@ -947,6 +1538,7 @@ export function listDmConversations({
         c.account_id,
         a.handle as account_handle,
         c.title,
+        c.inbox_kind,
         c.last_message_at,
         c.unread_count,
         c.needs_reply,
@@ -977,7 +1569,7 @@ export function listDmConversations({
       ${join}
       ${where}
       group by c.id
-      order by c.last_message_at desc
+      order by ${orderBy}
       limit ?
       `,
 		)
@@ -1014,6 +1606,8 @@ export function listDmConversations({
 			...(typeof row.search_snippet === "string"
 				? { searchSnippet: row.search_snippet }
 				: {}),
+			inboxKind: row.inbox_kind === "request" ? "request" : "accepted",
+			isMessageRequest: row.inbox_kind === "request",
 			lastMessageAt: String(row.last_message_at),
 			lastMessagePreview: String(row.last_message_preview ?? ""),
 			unreadCount: Number(row.unread_count),
@@ -1050,7 +1644,7 @@ export function listDmConversations({
 		return true;
 	});
 
-	if (sort === "influence") {
+	if (sort === "followers" || sort === "influence") {
 		filtered.sort((left, right) => {
 			if (
 				right.participant.followersCount !== left.participant.followersCount
@@ -1087,10 +1681,13 @@ export function listDmConversations({
 
 export function getConversationThread(
 	conversationId: string,
+	filters: Pick<DmQuery, "account"> = {},
 ): { conversation: DmConversationItem; messages: DmMessageItem[] } | null {
-	const conversation = listDmConversations({ limit: 100 }).find(
-		(item) => item.id === conversationId,
-	);
+	const conversation = listDmConversations({
+		...filters,
+		conversationIds: [conversationId],
+		limit: 1,
+	}).find((item) => item.id === conversationId);
 
 	if (!conversation) {
 		return null;
@@ -1150,6 +1747,54 @@ export function getConversationThread(
 	};
 }
 
+export type DmRequestMutationAction = "accept" | "reject" | "block";
+
+export function applyDmRequestMutationToLocalStore(
+	conversationId: string,
+	action: DmRequestMutationAction,
+) {
+	return persistWrite((db) => {
+		db.prepare(
+			"delete from sync_cache where cache_key like 'dms:bird:%'",
+		).run();
+		if (action === "accept") {
+			return db
+				.prepare(
+					`
+    update dm_conversations
+    set inbox_kind = 'accepted'
+    where id = ?
+    `,
+				)
+				.run(conversationId).changes;
+		}
+
+		db.prepare(
+			`
+    delete from link_occurrences
+    where source_kind = 'dm'
+      and source_id in (
+        select id from dm_messages where conversation_id = ?
+      )
+    `,
+		).run(conversationId);
+		db.prepare(
+			`
+    delete from dm_fts
+    where message_id in (
+      select id from dm_messages where conversation_id = ?
+    )
+    `,
+		).run(conversationId);
+		db.prepare("delete from dm_messages where conversation_id = ?").run(
+			conversationId,
+		);
+		return db
+			.prepare("delete from dm_conversations where id = ?")
+			.run(conversationId).changes;
+	});
+}
+
 function normalizeDmContext(value: number | undefined) {
 	if (typeof value !== "number" || !Number.isFinite(value)) {
 		return 0;
@@ -1316,12 +1961,19 @@ export function queryResource(
 	if (resource === "dms") {
 		const dmFilters = filters as DmQuery & { conversationId?: string };
 		const items = listDmConversations(dmFilters);
-		const selectedConversationId = dmFilters.conversationId ?? items[0]?.id;
+		const requestedConversationId = dmFilters.conversationId;
+		const selectedConversationId =
+			requestedConversationId &&
+			items.some((item) => item.id === requestedConversationId)
+				? requestedConversationId
+				: items[0]?.id;
 		return {
 			resource,
 			items,
 			selectedConversation: selectedConversationId
-				? getConversationThread(selectedConversationId)
+				? getConversationThread(selectedConversationId, {
+						account: dmFilters.account,
+					})
 				: null,
 		};
 	}
@@ -1342,16 +1994,36 @@ function refreshDmConversationState(
 	db: Database,
 	conversationId: string,
 	lastMessageAt: string,
+	observedLastMessageAt = lastMessageAt,
 ) {
 	db.prepare(
 		`
     update dm_conversations
-    set last_message_at = ?,
-        unread_count = 0,
-        needs_reply = 0
+    set last_message_at = case
+          when last_message_at < ? then ?
+          else last_message_at
+        end,
+        unread_count = case
+          when last_message_at = ? then 0
+          when last_message_at <= ? then 0
+          else unread_count
+        end,
+        needs_reply = case
+          when last_message_at = ? then 0
+          when last_message_at <= ? then 0
+          else needs_reply
+        end
     where id = ?
     `,
-	).run(lastMessageAt, conversationId);
+	).run(
+		lastMessageAt,
+		lastMessageAt,
+		observedLastMessageAt,
+		lastMessageAt,
+		observedLastMessageAt,
+		lastMessageAt,
+		conversationId,
+	);
 }
 
 function getLocalAuthorProfileId(accountId: string) {
@@ -1370,16 +2042,60 @@ function getLocalAuthorProfileId(accountId: string) {
 	return row?.id;
 }
 
-export async function createPost(accountId: string, text: string) {
+let savepointCounter = 0;
+
+function preflightWrite<T>(write: (db: Database) => T) {
+	const db = getNativeDb();
+	const savepoint = `__birdclaw_preflight_${++savepointCounter}`;
+	db.exec(`savepoint ${savepoint}`);
+	try {
+		const result = write(db);
+		db.exec(`rollback to ${savepoint}`);
+		db.exec(`release ${savepoint}`);
+		return result;
+	} catch (error) {
+		try {
+			db.exec(`rollback to ${savepoint}`);
+			db.exec(`release ${savepoint}`);
+		} catch {
+			// Preserve the original staging error; cleanup is best effort here.
+		}
+		throw error;
+	}
+}
+
+function persistWrite<T>(write: (db: Database) => T) {
 	const db = getNativeDb();
+	return db.transaction(() => write(db))();
+}
+
+type PostDraft = {
+	actionId: string;
+	authorProfileId: string;
+	createdAt: string;
+	tweetId: string;
+};
+
+function preparePostDraft(accountId: string): PostDraft {
 	const authorProfileId = getLocalAuthorProfileId(accountId);
 	if (!authorProfileId) {
 		throw new Error("No local author profile for account");
 	}
 
-	const now = new Date().toISOString();
-	const tweetId = `tweet_${randomUUID()}`;
+	return {
+		actionId: randomUUID(),
+		authorProfileId,
+		createdAt: new Date().toISOString(),
+		tweetId: `tweet_${randomUUID()}`,
+	};
+}
 
+function writePostDraft(
+	db: Database,
+	accountId: string,
+	text: string,
+	draft: PostDraft,
+) {
 	db.prepare(
 		`
     insert into tweets (
@@ -1387,88 +2103,207 @@ export async function createPost(accountId: string, text: string) {
       is_replied, reply_to_id, like_count, media_count, bookmarked, liked
     ) values (?, ?, ?, 'home', ?, ?, 0, null, 0, 0, 0, 0)
     `,
-	).run(tweetId, accountId, authorProfileId, text, now);
+	).run(draft.tweetId, accountId, draft.authorProfileId, text, draft.createdAt);
 
 	db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
-		tweetId,
+		draft.tweetId,
 		text,
 	);
 	db.prepare(
 		"insert into tweet_actions (id, account_id, tweet_id, kind, body, created_at) values (?, ?, ?, ?, ?, ?)",
-	).run(randomUUID(), accountId, tweetId, "post", text, now);
+	).run(
+		draft.actionId,
+		accountId,
+		draft.tweetId,
+		"post",
+		text,
+		draft.createdAt,
+	);
+}
 
-	const transport = await postViaXurl(text);
-	return { ok: true, transport, tweetId };
+export function createPostEffect(accountId: string, text: string) {
+	return Effect.gen(function* () {
+		const draft = yield* trySync(() => {
+			const postDraft = preparePostDraft(accountId);
+			preflightWrite((db) => writePostDraft(db, accountId, text, postDraft));
+			return postDraft;
+		});
+
+		yield* verifySelectedXurlAccountEffect(accountId);
+		const transport = yield* postViaXurlEffect(text);
+		if (!transport.ok) {
+			return yield* Effect.fail(new Error(transport.output || "post failed"));
+		}
+		yield* trySync(() =>
+			persistWrite((db) => writePostDraft(db, accountId, text, draft)),
+		);
+
+		return { ok: true, transport, tweetId: draft.tweetId };
+	});
+}
+
+export function createPost(accountId: string, text: string) {
+	return runEffectPromise(createPostEffect(accountId, text));
 }
 
-export async function createTweetReply(
+export function createTweetReplyEffect(
 	accountId: string,
 	tweetId: string,
 	text: string,
 ) {
-	const db = getNativeDb();
-	const authorProfileId = getLocalAuthorProfileId(accountId);
-	if (!authorProfileId) {
-		throw new Error("No local author profile for account");
+	type ReplyDraft = PostDraft & { replyId: string };
+
+	function prepareReplyDraft(): ReplyDraft {
+		const postDraft = preparePostDraft(accountId);
+		return {
+			...postDraft,
+			replyId: postDraft.tweetId,
+		};
 	}
 
-	const now = new Date().toISOString();
-	db.prepare("update tweets set is_replied = 1 where id = ?").run(tweetId);
+	function writeReplyDraft(db: Database, draft: ReplyDraft) {
+		db.prepare("update tweets set is_replied = 1 where id = ?").run(tweetId);
 
-	const replyId = `tweet_${randomUUID()}`;
-	db.prepare(
-		`
+		db.prepare(
+			`
     insert into tweets (
       id, account_id, author_profile_id, kind, text, created_at,
       is_replied, reply_to_id, like_count, media_count, bookmarked, liked
     ) values (?, ?, ?, 'home', ?, ?, 1, ?, 0, 0, 0, 0)
     `,
-	).run(replyId, accountId, authorProfileId, text, now, tweetId);
-	db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
-		replyId,
-		text,
-	);
+		).run(
+			draft.replyId,
+			accountId,
+			draft.authorProfileId,
+			text,
+			draft.createdAt,
+			tweetId,
+		);
+		db.prepare("insert into tweets_fts (tweet_id, text) values (?, ?)").run(
+			draft.replyId,
+			text,
+		);
 
-	db.prepare(
-		"insert into tweet_actions (id, account_id, tweet_id, kind, body, created_at) values (?, ?, ?, ?, ?, ?)",
-	).run(randomUUID(), accountId, tweetId, "reply", text, now);
+		db.prepare(
+			"insert into tweet_actions (id, account_id, tweet_id, kind, body, created_at) values (?, ?, ?, ?, ?, ?)",
+		).run(draft.actionId, accountId, tweetId, "reply", text, draft.createdAt);
+	}
+
+	return Effect.gen(function* () {
+		const draft = yield* trySync(() => {
+			const replyDraft = prepareReplyDraft();
+			preflightWrite((db) => writeReplyDraft(db, replyDraft));
+			return replyDraft;
+		});
+
+		yield* verifySelectedXurlAccountEffect(accountId);
+		const transport = yield* replyViaXurlEffect(tweetId, text);
+		if (!transport.ok) {
+			return yield* Effect.fail(new Error(transport.output || "reply failed"));
+		}
+		yield* trySync(() => persistWrite((db) => writeReplyDraft(db, draft)));
+
+		return { ok: true, transport, replyId: draft.replyId };
+	});
+}
 
-	const transport = await replyViaXurl(tweetId, text);
-	return { ok: true, transport, replyId };
+export function createTweetReply(
+	accountId: string,
+	tweetId: string,
+	text: string,
+) {
+	return runEffectPromise(createTweetReplyEffect(accountId, tweetId, text));
 }
 
-export async function createDmReply(conversationId: string, text: string) {
-	const db = getNativeDb();
-	const conversation = getConversationThread(conversationId);
-	if (!conversation) {
-		throw new Error("Conversation not found");
-	}
-	const authorProfileId = getLocalAuthorProfileId(
-		conversation.conversation.accountId,
-	);
-	if (!authorProfileId) {
-		throw new Error("No local author profile for account");
-	}
+export function createDmReplyEffect(conversationId: string, text: string) {
+	return Effect.gen(function* () {
+		const draft = yield* trySync(() => {
+			const conversation = getConversationThread(conversationId);
+			if (!conversation) {
+				throw new Error("Conversation not found");
+			}
+			const authorProfileId = getLocalAuthorProfileId(
+				conversation.conversation.accountId,
+			);
+			if (!authorProfileId) {
+				throw new Error("No local author profile for account");
+			}
 
-	const now = new Date().toISOString();
-	const outboundId = `msg_${randomUUID()}`;
+			const dmDraft = {
+				accountId: conversation.conversation.accountId,
+				authorProfileId,
+				createdAt: new Date().toISOString(),
+				handle: conversation.conversation.participant.handle,
+				observedLastMessageAt: conversation.conversation.lastMessageAt,
+				outboundId: `msg_${randomUUID()}`,
+			};
+			preflightWrite((db) => {
+				db.prepare(
+					`
+    insert into dm_messages (
+      id, conversation_id, sender_profile_id, text, created_at, direction, is_replied, media_count
+    ) values (?, ?, ?, ?, ?, 'outbound', 1, 0)
+    `,
+				).run(
+					dmDraft.outboundId,
+					conversationId,
+					dmDraft.authorProfileId,
+					text,
+					dmDraft.createdAt,
+				);
+				db.prepare("insert into dm_fts (message_id, text) values (?, ?)").run(
+					dmDraft.outboundId,
+					text,
+				);
 
-	db.prepare(
-		`
+				refreshDmConversationState(
+					db,
+					conversationId,
+					dmDraft.createdAt,
+					dmDraft.observedLastMessageAt,
+				);
+			});
+			return dmDraft;
+		});
+
+		yield* verifySelectedXurlAccountEffect(draft.accountId);
+		const transport = yield* dmViaXurlEffect(draft.handle, text);
+		if (!transport.ok) {
+			return yield* Effect.fail(new Error(transport.output || "dm failed"));
+		}
+		yield* trySync(() =>
+			persistWrite((db) => {
+				db.prepare(
+					`
     insert into dm_messages (
       id, conversation_id, sender_profile_id, text, created_at, direction, is_replied, media_count
     ) values (?, ?, ?, ?, ?, 'outbound', 1, 0)
     `,
-	).run(outboundId, conversationId, authorProfileId, text, now);
-	db.prepare("insert into dm_fts (message_id, text) values (?, ?)").run(
-		outboundId,
-		text,
-	);
+				).run(
+					draft.outboundId,
+					conversationId,
+					draft.authorProfileId,
+					text,
+					draft.createdAt,
+				);
+				db.prepare("insert into dm_fts (message_id, text) values (?, ?)").run(
+					draft.outboundId,
+					text,
+				);
 
-	refreshDmConversationState(db, conversationId, now);
-	const transport = await dmViaXurl(
-		conversation.conversation.participant.handle,
-		text,
-	);
-	return { ok: true, transport, messageId: outboundId };
+				refreshDmConversationState(
+					db,
+					conversationId,
+					draft.createdAt,
+					draft.observedLastMessageAt,
+				);
+			}),
+		);
+
+		return { ok: true, transport, messageId: draft.outboundId };
+	});
+}
+
+export function createDmReply(conversationId: string, text: string) {
+	return runEffectPromise(createDmReplyEffect(conversationId, text));
 }