@wirecat/cli-core 0.20.0 → 0.262.0

package/dist/store/sqlite/completeness.d.ts

@@ -0,0 +1,26 @@
+import type { Id } from "../../domain/models.js";
+import type { StoreContext } from "./open.js";
+/** The sync state that marks a chat fetched back to its first message (phase 2 plan S10). */
+export declare const historyStartKey: (chatId: Id) => string;
+/** Set when a `messages sync` run holds the chat's newest page; its `at` is when. */
+export declare const fetchedKey: (chatId: Id) => string;
+/** Set when the store was handed the account's whole chat list (`markChatsLeft`); its `at` is when. */
+export declare const CHAT_LIST_KEY = "chat_list_complete";
+export interface ChatCompleteness {
+    chatId: Id;
+    /** `unknown` when nothing ever fetched the chat's history: an empty answer then proves nothing. */
+    state: "complete" | "partial" | "unknown";
+    /** Holds the newest message the chat list knows of; `null` when the list gave no time. */
+    upToDate: boolean | null;
+    /** More than one stretch held, with history missing between them. */
+    gaps: boolean;
+    reachesStart: boolean;
+    /** When a `messages sync` last read the chat's newest page; `null` when none has. */
+    fetchedAt: string | null;
+}
+/**
+ * Three facts per chat (NEED-455 A): the newest held against the chat list's, the stretches, and the start reached.
+ * A start mark that a later fetch reached past was wrong, so it stops counting.
+ */
+export declare const chatCompleteness: ({ database }: StoreContext, accountKey: number, chatIds: Id[]) => ChatCompleteness[];
+//# sourceMappingURL=completeness.d.ts.map

package/dist/store/sqlite/completeness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completeness.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/completeness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAG7C,6FAA6F;AAC7F,eAAO,MAAM,eAAe,WAAY,EAAE,KAAG,MAAmC,CAAA;AAChF,qFAAqF;AACrF,eAAO,MAAM,UAAU,WAAY,EAAE,KAAG,MAA6B,CAAA;AACrE,uGAAuG;AACvG,eAAO,MAAM,aAAa,uBAAuB,CAAA;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,EAAE,CAAA;IACV,mGAAmG;IACnG,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAA;IACzC,0FAA0F;IAC1F,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAA;IACxB,qEAAqE;IACrE,IAAI,EAAE,OAAO,CAAA;IACb,YAAY,EAAE,OAAO,CAAA;IACrB,qFAAqF;IACrF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,iBAAkB,YAAY,cAAc,MAAM,WAAW,EAAE,EAAE,KAAG,gBAAgB,EA8BhH,CAAA"}

package/dist/store/sqlite/completeness.js

@@ -0,0 +1,42 @@
+import { toIso } from "./values.js";
+/** The sync state that marks a chat fetched back to its first message (phase 2 plan S10). */
+export const historyStartKey = (chatId) => `history_start:${chatId}`;
+/** Set when a `messages sync` run holds the chat's newest page; its `at` is when. */
+export const fetchedKey = (chatId) => `fetched:${chatId}`;
+/** Set when the store was handed the account's whole chat list (`markChatsLeft`); its `at` is when. */
+export const CHAT_LIST_KEY = "chat_list_complete";
+/**
+ * Three facts per chat (NEED-455 A): the newest held against the chat list's, the stretches, and the start reached.
+ * A start mark that a later fetch reached past was wrong, so it stops counting.
+ */
+export const chatCompleteness = ({ database }, accountKey, chatIds) => {
+    if (chatIds.length === 0)
+        return [];
+    return database
+        .prepare(`SELECT c.external_id AS chat, c.last_message_at AS newest,
+         (SELECT max(m.sent_at) FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL) AS held,
+         (SELECT count(*) FROM sync_ranges r WHERE r.chat_id = c.id) AS stretches,
+         EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id AND s.key = 'history_start:' || c.external_id
+           AND NOT EXISTS (SELECT 1 FROM sync_ranges r WHERE r.chat_id = c.id AND r.from_key < CAST(s.value AS INTEGER)))
+           AS start,
+         (SELECT s.updated_at FROM sync_cursors s WHERE s.account_id = c.account_id AND s.key = 'fetched:' || c.external_id)
+           AS fetched
+       FROM chats c WHERE c.account_id = ? AND c.external_id IN (${chatIds.map(() => "?").join(", ")})`)
+        .all(accountKey, ...chatIds)
+        .map((row) => {
+        const stretches = Number(row.stretches);
+        const reachesStart = Number(row.start) === 1;
+        const upToDate = row.newest === null ? null : row.held !== null && Number(row.held) >= Number(row.newest);
+        const gaps = stretches > 1;
+        const fetched = stretches > 0 || reachesStart;
+        return {
+            chatId: String(row.chat),
+            state: !fetched ? "unknown" : upToDate !== false && !gaps && reachesStart ? "complete" : "partial",
+            upToDate,
+            gaps,
+            reachesStart,
+            fetchedAt: toIso(row.fetched),
+        };
+    });
+};
+//# sourceMappingURL=completeness.js.map

package/dist/store/sqlite/completeness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completeness.js","sourceRoot":"","sources":["../../../src/store/sqlite/completeness.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC,6FAA6F;AAC7F,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAU,EAAU,EAAE,CAAC,iBAAiB,MAAM,EAAE,CAAA;AAChF,qFAAqF;AACrF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAU,EAAU,EAAE,CAAC,WAAW,MAAM,EAAE,CAAA;AACrE,uGAAuG;AACvG,MAAM,CAAC,MAAM,aAAa,GAAG,oBAAoB,CAAA;AAejD;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,EAAE,QAAQ,EAAgB,EAAE,UAAkB,EAAE,OAAa,EAAsB,EAAE;IACpH,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IACnC,OAAO,QAAQ;SACZ,OAAO,CACN;;;;;;;;mEAQ6D,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAClG;SACA,GAAG,CAAC,UAAU,EAAE,GAAG,OAAO,CAAC;SAC3B,GAAG,CAAC,CAAC,GAAG,EAAoB,EAAE;QAC7B,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;QACvC,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QAC5C,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACzG,MAAM,IAAI,GAAG,SAAS,GAAG,CAAC,CAAA;QAC1B,MAAM,OAAO,GAAG,SAAS,GAAG,CAAC,IAAI,YAAY,CAAA;QAC7C,OAAO;YACL,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;YACxB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,KAAK,KAAK,IAAI,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;YAClG,QAAQ;YACR,IAAI;YACJ,YAAY;YACZ,SAAS,EAAE,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;SAC9B,CAAA;IACH,CAAC,CAAC,CAAA;AACN,CAAC,CAAA"}

package/dist/store/sqlite/conversation-eligibility.d.ts

@@ -0,0 +1,12 @@
+import type { QueryExecution } from "../../search/lucene/resolved.js";
+import type { AccountKey } from "../store.js";
+import type { StoreContext } from "./open.js";
+export interface ConversationEligibility {
+    conversations: string[];
+    chats: {
+        account: AccountKey;
+        chat: string;
+    }[];
+}
+export declare const conversationEligibility: (context: StoreContext, execution: QueryExecution) => Promise<ConversationEligibility>;
+//# sourceMappingURL=conversation-eligibility.d.ts.map

package/dist/store/sqlite/conversation-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-eligibility.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/conversation-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAE7C,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC/C;AAED,eAAO,MAAM,uBAAuB,YACzB,YAAY,aACV,cAAc,KACxB,OAAO,CAAC,uBAAuB,CAoBjC,CAAA"}

package/dist/store/sqlite/conversation-eligibility.js

@@ -0,0 +1,24 @@
+import { queryMessagePks } from "./lucene.js";
+export const conversationEligibility = async (context, execution) => {
+    if (!execution.accounts.length)
+        return { conversations: [], chats: [] };
+    const pks = JSON.stringify(await queryMessagePks(context, execution));
+    const conversations = context.database
+        .prepare(`SELECT DISTINCT cv.id AS id FROM conversation_messages cm
+    JOIN conversations cv ON cv.id=cm.conversation_id
+    JOIN conversation_state cs ON cs.chat_id=cv.chat_id AND cs.current_build=cv.build
+    WHERE cm.message_id IN (SELECT value FROM json_each(?))`)
+        .all(pks)
+        .map(({ id }) => String(id));
+    const chats = context.database
+        .prepare(`SELECT DISTINCT ac.provider, ac.external_id AS account, ch.external_id AS chat
+    FROM messages m JOIN chats ch ON ch.id=m.chat_id JOIN accounts ac ON ac.id=m.account_id
+    WHERE m.id IN (SELECT value FROM json_each(?))`)
+        .all(pks)
+        .map((row) => ({
+        account: { provider: String(row.provider), account: String(row.account) },
+        chat: String(row.chat),
+    }));
+    return { conversations, chats };
+};
+//# sourceMappingURL=conversation-eligibility.js.map

package/dist/store/sqlite/conversation-eligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-eligibility.js","sourceRoot":"","sources":["../../../src/store/sqlite/conversation-eligibility.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAQ7C,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAC1C,OAAqB,EACrB,SAAyB,EACS,EAAE;IACpC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM;QAAE,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAA;IACvE,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAA;IACrE,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ;SACnC,OAAO,CAAC;;;4DAG+C,CAAC;SACxD,GAAG,CAAC,GAAG,CAAC;SACR,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAA;IAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ;SAC3B,OAAO,CAAC;;mDAEsC,CAAC;SAC/C,GAAG,CAAC,GAAG,CAAC;SACR,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACb,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;QACzE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;KACvB,CAAC,CAAC,CAAA;IACL,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAA;AACjC,CAAC,CAAA"}

package/dist/store/sqlite/conversations.d.ts

@@ -0,0 +1,57 @@
+import type { LinkInput } from "../../conversations/link.js";
+import type { Id, Message, Page } from "../../domain/models.js";
+import type { ConversationBuild, ConversationSummary, StoredLink } from "../store.js";
+import type { StoreContext } from "./open.js";
+/** A chat's live messages for the rules, oldest first, a page at a time; `next` continues it. */
+export declare const linkInputs: ({ orm }: StoreContext, chatKey: number, { after, limit }: {
+    after?: string;
+    limit: number;
+}) => {
+    items: LinkInput[];
+    next: string | null;
+};
+/** The usernames of everyone who wrote in the chat, lowercased, to their id: what a mention names. */
+export declare const senderHandles: ({ orm }: StoreContext, chatKey: number) => Map<string, Id>;
+/**
+ * Plan C3–C4, corrected by NEED-475 A. The chat's provider and rule links and its conversations are
+ * written under a new build number in short transactions; one more makes that build the one readers
+ * see; older builds are then deleted, a batch at a time. Until the switch readers see the previous
+ * build, so a failed build leaves it in place. Agent links have no build and stay; one whose message
+ * or parent was edited or deleted after it was written is marked stale.
+ */
+export declare const replaceConversations: (context: StoreContext, chatKey: number, { startedAt, algorithmVersion, links, conversations: groups, chunks, check }: ConversationBuild, batch?: number) => Promise<void>;
+/** Newest first. `after` and `before` bound when a conversation started. */
+export declare const conversationPage: (context: StoreContext, chatKey: number, { limit, after, before }: {
+    limit: number;
+    after?: number;
+    before?: number;
+}) => {
+    items: ConversationSummary[];
+    hasMore: boolean;
+};
+/** The current build's summaries of these conversations, by pk; another account's are left out. */
+export declare const summariesOf: (context: StoreContext, accountKey: number, pks: number[]) => Map<number, ConversationSummary>;
+/** Its messages oldest first — only an account's own conversation. */
+export declare const conversation: (context: StoreContext, accountKey: number, id: number) => {
+    summary: ConversationSummary;
+    messages: Message[];
+} | undefined;
+export declare const conversationOf: ({ orm }: StoreContext, chatKey: number, messageId: Id) => string | undefined;
+/** Every link a message has, the messenger's first, then the strongest. */
+export declare const linksOf: ({ orm }: StoreContext, chatKey: number, messageId: Id, limit?: number) => StoredLink[];
+/** Candidates only: the caller checks which parent each child chooses, using the same link reader. */
+export declare const repliesTo: ({ orm }: StoreContext, chatKey: number, messageId: Id, limit: number) => Page<{
+    messageId: Id;
+}>;
+export declare const stateOf: ({ orm }: StoreContext, chatKey: number) => {
+    enabledAt: string;
+    builtAt: string | null;
+    algorithmVersion: number | null;
+} | undefined;
+/**
+ * The user's agent's current answer per message (phase 4 plan A6): its parent, or `null` for "starts a
+ * conversation". An answer whose message or parent was edited or deleted after it was written is left
+ * out here already — a rebuild marks it stale only when it finishes.
+ */
+export declare const agentAnswers: ({ orm }: StoreContext, chatKey: number) => Map<Id, Id | null>;
+//# sourceMappingURL=conversations.d.ts.map

package/dist/store/sqlite/conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversations.d.ts","sourceRoot":"","sources":["../../../src/store/sqlite/conversations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAQ,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAA;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAGrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAmB7C,iGAAiG;AACjG,eAAO,MAAM,UAAU,YACZ,YAAY,WACZ,MAAM,oBACG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAClD;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAwC3C,CAAA;AAED,sGAAsG;AACtG,eAAO,MAAM,aAAa,YAAa,YAAY,WAAW,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,EAAE,CASlF,CAAA;AA+CH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,YACtB,YAAY,WACZ,MAAM,gFACoE,iBAAiB,qBAEnG,OAAO,CAAC,IAAI,CAwOd,CAAA;AAyDD,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,YAClB,YAAY,WACZ,MAAM,4BACW;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KAC3E;IAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAclD,CAAA;AAED,mGAAmG;AACnG,eAAO,MAAM,WAAW,YACb,YAAY,cACT,MAAM,OACb,MAAM,EAAE,KACZ,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAiB/B,CAAA;AAEH,sEAAsE;AACtE,eAAO,MAAM,YAAY,YACd,YAAY,cACT,MAAM,MACd,MAAM,KACT;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,SAgB1D,CAAA;AAED,eAAO,MAAM,cAAc,YAAa,YAAY,WAAW,MAAM,aAAa,EAAE,KAAG,MAAM,GAAG,SAS/F,CAAA;AAcD,2EAA2E;AAC3E,eAAO,MAAM,OAAO,YAAa,YAAY,WAAW,MAAM,aAAa,EAAE,UAAU,MAAM,KAAG,UAAU,EA8BnG,CAAA;AAEP,sGAAsG;AACtG,eAAO,MAAM,SAAS,YACX,YAAY,WACZ,MAAM,aACJ,EAAE,SACN,MAAM,KACZ,IAAI,CAAC;IAAE,SAAS,EAAE,EAAE,CAAA;CAAE,CAmBxB,CAAA;AAED,eAAO,MAAM,OAAO,YAAa,YAAY,WAAW,MAAM;eAIjB,MAAM;;;aAKlD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,YAAa,YAAY,WAAW,MAAM,KAAG,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,CAapF,CAAA"}

package/dist/store/sqlite/conversations.js

@@ -0,0 +1,448 @@
+import { setTimeout } from "node:timers/promises";
+import { and, asc, desc, eq, isNull, sql } from "./drizzle/core.js";
+import { linkKind } from "./link-kinds.js";
+import { selectMessages, toMessages } from "./reads.js";
+import { accounts, chats, chunkMessages, chunks as chunkRows, conversationMessages, conversationState, conversations, identities, messageLinks, messages, } from "./schema.js";
+import { toIso } from "./values.js";
+import { purgeVectorHashes } from "./vectors.js";
+const position = (sentAt, pk) => `${sentAt}:${pk}`;
+/** A chat's live messages for the rules, oldest first, a page at a time; `next` continues it. */
+export const linkInputs = ({ orm }, chatKey, { after, limit }) => {
+    const [sentAt, pk] = (after ?? "").split(":").map(Number);
+    const rows = orm
+        .select({
+        pk: messages.id,
+        id: messages.externalId,
+        senderId: sql `coalesce(${messages.senderChatExternalId}, ${identities.externalId})`,
+        senderName: messages.senderName,
+        text: messages.text,
+        sentAt: messages.sentAt,
+        replyToId: messages.replyToExternalId,
+        threadId: messages.threadExternalId,
+        mentions: messages.mentions,
+    })
+        .from(messages)
+        .leftJoin(identities, eq(identities.id, messages.senderIdentityId))
+        .where(and(eq(messages.chatId, chatKey), isNull(messages.deletedAt), after === undefined ? undefined : sql `(${messages.sentAt}, ${messages.id}) > (${sentAt}, ${pk})`))
+        .orderBy(asc(messages.sentAt), asc(messages.id))
+        .limit(limit)
+        .all();
+    const last = rows.at(-1);
+    return {
+        items: rows.map((row) => ({
+            id: row.id,
+            senderId: row.senderId,
+            senderName: row.senderName,
+            text: row.text,
+            timestamp: toIso(row.sentAt),
+            ...(row.replyToId === null ? {} : { replyToId: row.replyToId }),
+            ...(row.threadId === null ? {} : { threadId: row.threadId }),
+            ...(row.mentions === null ? {} : { mentions: JSON.parse(row.mentions) }),
+        })),
+        next: rows.length === limit && last ? position(last.sentAt, last.pk) : null,
+    };
+};
+/** The usernames of everyone who wrote in the chat, lowercased, to their id: what a mention names. */
+export const senderHandles = ({ orm }, chatKey) => new Map(orm
+    .selectDistinct({ username: identities.username, id: identities.externalId })
+    .from(messages)
+    .innerJoin(identities, eq(identities.id, messages.senderIdentityId))
+    .where(and(eq(messages.chatId, chatKey), sql `${identities.username} IS NOT NULL`))
+    .all()
+    .map(({ username, id }) => [String(username).toLowerCase(), id]));
+const inChat = (chatKey) => eq(messageLinks.chatId, chatKey);
+/**
+ * A long write cut into short transactions with a pause between them. Without the pause the next
+ * `BEGIN IMMEDIATE` wins the lock again at once: a process waiting for it sleeps up to 100 ms at a time
+ * and, measured, waited out the whole build (1.8 s of 1.9 s at 100k messages). It gives up at 5 s.
+ * `work` writes one row per step, synchronously: nothing awaits while a transaction is open (D3).
+ */
+const inTurns = async ({ database }, work, { holdMs = 250, pauseMs = 120 } = {}) => {
+    for (let done = false; !done;) {
+        database.exec("BEGIN IMMEDIATE");
+        try {
+            const since = performance.now();
+            do
+                done = work.next().done === true;
+            while (!done && performance.now() - since < holdMs);
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+        if (!done)
+            await setTimeout(pauseMs);
+    }
+};
+const once = (body) => ({
+    next: () => {
+        body();
+        return { done: true, value: undefined };
+    },
+});
+const highestBuild = ({ orm }, chatKey) => Number(orm
+    .select({
+    n: sql `max(
+          coalesce((SELECT max(${conversations.build}) FROM ${conversations} WHERE ${conversations.chatId} = ${chatKey}), 0),
+          coalesce((SELECT max(${messageLinks.build}) FROM ${messageLinks} WHERE ${inChat(chatKey)}), 0),
+          coalesce((SELECT ${conversationState.currentBuild} FROM ${conversationState}
+            WHERE ${conversationState.chatId} = ${chatKey}), 0))`,
+})
+    .from(sql `(SELECT 1)`)
+    .get()?.n);
+/**
+ * Plan C3–C4, corrected by NEED-475 A. The chat's provider and rule links and its conversations are
+ * written under a new build number in short transactions; one more makes that build the one readers
+ * see; older builds are then deleted, a batch at a time. Until the switch readers see the previous
+ * build, so a failed build leaves it in place. Agent links have no build and stay; one whose message
+ * or parent was edited or deleted after it was written is marked stale.
+ */
+export const replaceConversations = async (context, chatKey, { startedAt, algorithmVersion, links, conversations: groups, chunks = [], check }, batch = 5_000) => {
+    const { orm, now } = context;
+    check?.();
+    const oldHashes = orm.all(sql `SELECT DISTINCT k.content_hash AS hash FROM chunks k JOIN conversations c ON k.chunkable_type = 'conversation' AND c.id = k.chunkable_id WHERE c.chat_id = ${chatKey}`);
+    const held = new Map(orm
+        .select({
+        id: messages.externalId,
+        pk: messages.id,
+        sentAt: messages.sentAt,
+        text: messages.text,
+        senderName: messages.senderName,
+    })
+        .from(messages)
+        .where(eq(messages.chatId, chatKey))
+        .all()
+        .map((row) => [row.id, row]));
+    let build = 0;
+    await inTurns(context, once(() => {
+        // By start time, so a build that started later is the newer one; never one already used.
+        build = Math.max(startedAt, highestBuild(context, chatKey) + 1);
+        orm.insert(conversationState).values({ chatId: chatKey, enabledAt: startedAt }).onConflictDoNothing().run();
+    }));
+    const chunkScope = orm
+        .select({ accountId: chats.accountId, scope: sql `coalesce(${chats.scope}, ${accounts.scope})` })
+        .from(chats)
+        .innerJoin(accounts, eq(accounts.id, chats.accountId))
+        .where(eq(chats.id, chatKey))
+        .get();
+    const project = context.database
+        .prepare(`SELECT to_id FROM links WHERE from_type='chat' AND from_id=? AND to_type='project' AND kind=${linkKind("member-of")} AND confirmed=1 ORDER BY id LIMIT 1`)
+        .get(chatKey);
+    const insertLink = orm
+        .insert(messageLinks)
+        .values({
+        chatId: chatKey,
+        messageId: sql.placeholder("messageId"),
+        parentId: sql.placeholder("parentId"),
+        source: sql.placeholder("source"),
+        kind: sql.placeholder("kind"),
+        confidence: sql.placeholder("confidence"),
+        method: sql.placeholder("method"),
+        version: String(algorithmVersion),
+        createdAt: startedAt,
+        updatedAt: startedAt,
+        build,
+    })
+        .onConflictDoNothing()
+        .prepare();
+    const insertPiece = orm
+        .insert(chunkRows)
+        .values({
+        chunkableType: "conversation",
+        chunkableId: sql.placeholder("conversationId"),
+        position: sql.placeholder("position"),
+        startOffset: sql.placeholder("startOffset"),
+        endOffset: sql.placeholder("endOffset"),
+        contentHash: sql.placeholder("contentHash"),
+        projectId: project ? Number(project.to_id) : null,
+        accountId: chunkScope?.accountId ?? null,
+        scope: chunkScope?.scope ?? null,
+        occurredAt: sql.placeholder("occurredAt"),
+        createdAt: startedAt,
+        updatedAt: startedAt,
+    })
+        .returning({ id: chunkRows.id })
+        .prepare();
+    const insertRange = orm
+        .insert(chunkMessages)
+        .values({
+        chunkId: sql.placeholder("chunkId"),
+        firstMessageId: sql.placeholder("firstMessageId"),
+        lastMessageId: sql.placeholder("lastMessageId"),
+        textStart: sql.placeholder("textStart"),
+        textEnd: sql.placeholder("textEnd"),
+    })
+        .prepare();
+    const insertMember = orm
+        .insert(conversationMessages)
+        .values({ conversationId: sql.placeholder("conversationId"), messageId: sql.placeholder("messageId") })
+        .prepare();
+    await inTurns(context, (function* () {
+        for (const link of links) {
+            check?.();
+            const message = held.get(link.messageId);
+            const parent = held.get(link.parentId);
+            if (!message || !parent)
+                continue;
+            insertLink.run(row(link, message.pk, parent.pk));
+            yield;
+        }
+        for (const [index, ids] of groups.entries()) {
+            check?.();
+            const members = ids.flatMap((id) => held.get(id) ?? []);
+            const first = members[0];
+            if (!first)
+                continue;
+            const created = orm
+                .insert(conversations)
+                .values({
+                chatId: chatKey,
+                build,
+                firstMessageId: first.pk,
+                firstAt: first.sentAt,
+                lastAt: members.reduce((last, member) => Math.max(last, member.sentAt), first.sentAt),
+                messageCount: members.length,
+                builtAt: startedAt,
+                createdAt: startedAt,
+                updatedAt: startedAt,
+                algorithmVersion,
+            })
+                .returning({ pk: conversations.id })
+                .get();
+            for (const member of members) {
+                check?.();
+                insertMember.run({ conversationId: created.pk, messageId: member.pk });
+                yield;
+            }
+            const offsets = new Map();
+            if ((chunks[index]?.length ?? 0) > 0) {
+                let offset = 0;
+                for (const member of members) {
+                    const prefix = member.senderName ? member.senderName.length + 2 : 0;
+                    offsets.set(member.id, { start: offset, end: offset + prefix + member.text.length, prefix });
+                    offset += prefix + member.text.length + 1;
+                }
+            }
+            for (const [ordinal, chunk] of (chunks[index] ?? []).entries()) {
+                check?.();
+                const from = held.get(chunk.firstId);
+                const to = held.get(chunk.lastId);
+                if (!from || !to)
+                    continue;
+                const row = insertPiece.get({
+                    conversationId: created.pk,
+                    position: ordinal,
+                    startOffset: (offsets.get(from.id)?.start ?? 0) +
+                        (chunk.range ? (offsets.get(from.id)?.prefix ?? 0) + chunk.range.start : 0),
+                    endOffset: chunk.range
+                        ? (offsets.get(to.id)?.start ?? 0) + (offsets.get(to.id)?.prefix ?? 0) + chunk.range.end
+                        : (offsets.get(to.id)?.end ?? 0),
+                    contentHash: chunk.hash,
+                    occurredAt: from.sentAt,
+                });
+                insertRange.run({
+                    chunkId: Number(row?.id),
+                    firstMessageId: from.pk,
+                    lastMessageId: to.pk,
+                    textStart: chunk.range?.start ?? null,
+                    textEnd: chunk.range?.end ?? null,
+                });
+                yield;
+            }
+        }
+    })());
+    const changedSince = (end) => sql `(
+    EXISTS (SELECT 1 FROM message_revisions r WHERE r.message_id = ${end} AND r.created_at > ${messageLinks.createdAt})
+    OR EXISTS (SELECT 1 FROM messages d WHERE d.id = ${end} AND d.deleted_at > ${messageLinks.createdAt}))`;
+    await inTurns(context, once(() => {
+        check?.();
+        orm
+            .update(messageLinks)
+            .set({ staleAt: now() })
+            .where(and(eq(messageLinks.source, "agent"), isNull(messageLinks.staleAt), inChat(chatKey), sql `(${changedSince(sql `${messageLinks.messageId}`)} OR ${changedSince(sql `${messageLinks.parentId}`)})`))
+            .run();
+        // A slower build that started earlier and finishes later must not replace a newer one.
+        orm
+            .update(conversationState)
+            .set({ currentBuild: build, builtAt: startedAt, algorithmVersion })
+            .where(and(eq(conversationState.chatId, chatKey), sql `coalesce(${conversationState.currentBuild}, 0) < ${build}`))
+            .run();
+        orm.run(sql `DELETE FROM chunks WHERE chunkable_type='conversation' AND chunkable_id IN (SELECT id FROM conversations WHERE chat_id=${chatKey} AND build < (SELECT current_build FROM conversation_state WHERE chat_id=${chatKey}))`);
+    }));
+    const current = sql `(SELECT ${conversationState.currentBuild} FROM ${conversationState}
+    WHERE ${conversationState.chatId} = ${chatKey})`;
+    await inTurns(context, (function* () {
+        for (;;) {
+            const removed = orm
+                .delete(conversations)
+                .where(sql `${conversations.id} IN (SELECT ${conversations.id} FROM ${conversations}
+              WHERE ${conversations.chatId} = ${chatKey} AND ${conversations.build} < ${current} LIMIT ${batch})`)
+                .returning({ pk: conversations.id })
+                .all().length +
+                orm
+                    .delete(messageLinks)
+                    .where(sql `rowid IN (SELECT rowid FROM ${messageLinks} WHERE ${messageLinks.chatId} = ${chatKey}
+              AND ${messageLinks.build} < ${current} LIMIT ${batch})`)
+                    .returning({ pk: messageLinks.messageId })
+                    .all().length;
+            if (removed === 0)
+                return;
+            yield;
+        }
+    })());
+    purgeVectorHashes(context, oldHashes.map(({ hash }) => hash));
+};
+const row = (link, messagePk, parentPk) => ({
+    messageId: messagePk,
+    parentId: parentPk,
+    source: link.source,
+    kind: link.kind,
+    confidence: link.confidence,
+    method: link.method,
+});
+/** Only the build readers see; a newer one may be half written. */
+const isCurrent = sql `${conversations.build} = (SELECT ${conversationState.currentBuild} FROM ${conversationState}
+  WHERE ${conversationState.chatId} = ${conversations.chatId})`;
+const SUMMARY = {
+    pk: conversations.id,
+    chatId: chats.externalId,
+    firstMessageId: messages.externalId,
+    firstAt: conversations.firstAt,
+    lastAt: conversations.lastAt,
+    messageCount: conversations.messageCount,
+    builtAt: conversations.builtAt,
+    algorithmVersion: conversations.algorithmVersion,
+    senders: sql `(SELECT count(DISTINCT coalesce(m.sender_chat_external_id, m.sender_identity_id))
+    FROM conversation_messages cm JOIN messages m ON m.id = cm.message_id WHERE cm.conversation_id = ${conversations.id})`,
+};
+const summaries = ({ orm }) => orm
+    .select(SUMMARY)
+    .from(conversations)
+    .innerJoin(chats, eq(chats.id, conversations.chatId))
+    .innerJoin(messages, eq(messages.id, conversations.firstMessageId));
+const toSummary = (row) => ({
+    id: String(row.pk),
+    chatId: row.chatId,
+    firstMessageId: row.firstMessageId,
+    firstAt: toIso(row.firstAt),
+    lastAt: toIso(row.lastAt),
+    messageCount: row.messageCount,
+    senders: Number(row.senders),
+    builtAt: toIso(row.builtAt),
+    algorithmVersion: row.algorithmVersion,
+});
+/** Newest first. `after` and `before` bound when a conversation started. */
+export const conversationPage = (context, chatKey, { limit, after, before }) => {
+    const rows = summaries(context)
+        .where(and(eq(conversations.chatId, chatKey), isCurrent, after === undefined ? undefined : sql `${conversations.firstAt} >= ${after}`, before === undefined ? undefined : sql `${conversations.firstAt} < ${before}`))
+        .orderBy(desc(conversations.firstAt), desc(conversations.id))
+        .limit(limit + 1)
+        .all();
+    return { items: rows.slice(0, limit).map(toSummary), hasMore: rows.length > limit };
+};
+/** The current build's summaries of these conversations, by pk; another account's are left out. */
+export const summariesOf = (context, accountKey, pks) => new Map(pks.length === 0
+    ? []
+    : summaries(context)
+        .where(and(sql `${conversations.id} IN (${sql.join(pks.map((pk) => sql `${pk}`), sql `, `)})`, eq(chats.accountId, accountKey), isCurrent))
+        .all()
+        .map((row) => [row.pk, toSummary(row)]));
+/** Its messages oldest first — only an account's own conversation. */
+export const conversation = (context, accountKey, id) => {
+    const found = summaries(context)
+        .where(and(eq(conversations.id, id), eq(chats.accountId, accountKey), isCurrent))
+        .get();
+    if (!found)
+        return undefined;
+    const rows = selectMessages(context)
+        .where(and(isNull(messages.deletedAt), sql `${messages.id} IN (SELECT ${conversationMessages.messageId} FROM ${conversationMessages}
+          WHERE ${conversationMessages.conversationId} = ${id})`))
+        .orderBy(asc(messages.sentAt), asc(messages.id))
+        .all();
+    return { summary: toSummary(found), messages: toMessages(context, rows) };
+};
+export const conversationOf = ({ orm }, chatKey, messageId) => {
+    const found = orm
+        .select({ pk: conversationMessages.conversationId })
+        .from(conversationMessages)
+        .innerJoin(messages, eq(messages.id, conversationMessages.messageId))
+        .innerJoin(conversations, eq(conversations.id, conversationMessages.conversationId))
+        .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), isCurrent))
+        .get();
+    return found ? String(found.pk) : undefined;
+};
+const staleLink = (chatKey) => sql `(${messageLinks.staleAt} IS NOT NULL
+  OR EXISTS (SELECT 1 FROM message_revisions r WHERE r.message_id IN (${messageLinks.messageId}, ${messageLinks.parentId})
+    AND r.created_at >= ${messageLinks.createdAt})
+  OR EXISTS (SELECT 1 FROM messages d WHERE d.id IN (${messageLinks.messageId}, ${messageLinks.parentId}) AND (d.deleted_at IS NOT NULL OR d.edited_at > ${messageLinks.createdAt}))
+  OR (${messageLinks.source} = 'provider' AND ${messageLinks.kind} = 'reply' AND
+    (SELECT m.reply_to_external_id FROM messages m WHERE m.id = ${messageLinks.messageId}) IS NOT
+    (SELECT p.external_id FROM messages p WHERE p.id = ${messageLinks.parentId}))
+  OR EXISTS (SELECT 1 FROM messages p WHERE p.id = ${messageLinks.parentId} AND p.chat_id <> ${chatKey}))`;
+const currentLink = (chatKey) => sql `(${messageLinks.build} IS NULL OR ${messageLinks.build} =
+  (SELECT ${conversationState.currentBuild} FROM ${conversationState} WHERE ${conversationState.chatId} = ${chatKey}))`;
+/** Every link a message has, the messenger's first, then the strongest. */
+export const linksOf = ({ orm }, chatKey, messageId, limit) => orm
+    .select({
+    parentId: sql `(SELECT p.external_id FROM messages p WHERE p.id = ${messageLinks.parentId} AND p.chat_id = ${chatKey})`,
+    source: messageLinks.source,
+    kind: messageLinks.kind,
+    confidence: messageLinks.confidence,
+    method: messageLinks.method,
+    version: messageLinks.version,
+    createdAt: messageLinks.createdAt,
+    stale: staleLink(chatKey),
+})
+    .from(messageLinks)
+    .innerJoin(messages, eq(messages.id, messageLinks.messageId))
+    .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), currentLink(chatKey)))
+    .orderBy(sql `CASE ${messageLinks.source} WHEN 'provider' THEN 0 WHEN 'agent' THEN 1 ELSE 2 END`, desc(messageLinks.confidence), desc(messageLinks.createdAt), messageLinks.parentId)
+    .limit(limit ?? -1)
+    .all()
+    .map(({ createdAt, stale, ...link }) => ({
+    ...link,
+    source: link.source,
+    createdAt: toIso(createdAt),
+    stale: Boolean(stale),
+}));
+/** Candidates only: the caller checks which parent each child chooses, using the same link reader. */
+export const repliesTo = ({ orm }, chatKey, messageId, limit) => {
+    const rows = orm
+        .select({ messageId: messages.externalId })
+        .from(messageLinks)
+        .innerJoin(messages, eq(messages.id, messageLinks.messageId))
+        .where(and(eq(messages.chatId, chatKey), currentLink(chatKey), sql `${messageLinks.parentId} = (SELECT p.id FROM messages p WHERE p.chat_id = ${chatKey} AND p.external_id = ${messageId})`))
+        .orderBy(sql `${messageLinks}.rowid`)
+        .limit(limit + 1)
+        .all();
+    return {
+        items: [...new Map(rows.slice(0, limit).map((row) => [row.messageId, row])).values()],
+        hasMore: rows.length > limit,
+    };
+};
+export const stateOf = ({ orm }, chatKey) => {
+    const found = orm.select().from(conversationState).where(eq(conversationState.chatId, chatKey)).get();
+    return found
+        ? {
+            enabledAt: toIso(found.enabledAt),
+            builtAt: toIso(found.builtAt),
+            algorithmVersion: found.algorithmVersion,
+        }
+        : undefined;
+};
+/**
+ * The user's agent's current answer per message (phase 4 plan A6): its parent, or `null` for "starts a
+ * conversation". An answer whose message or parent was edited or deleted after it was written is left
+ * out here already — a rebuild marks it stale only when it finishes.
+ */
+export const agentAnswers = ({ orm }, chatKey) => new Map(orm
+    .all(sql `SELECT m.external_id AS id, p.external_id AS parent FROM message_links l
+          JOIN messages m ON m.id = l.message_id LEFT JOIN messages p ON p.id = l.parent_id
+          WHERE l.chat_id = ${chatKey} AND l.source = 'agent' AND l.stale_at IS NULL
+            AND NOT EXISTS (SELECT 1 FROM message_revisions r
+              WHERE r.message_id IN (l.message_id, l.parent_id) AND r.created_at > l.created_at)
+            AND NOT EXISTS (SELECT 1 FROM messages d
+              WHERE d.id IN (l.message_id, l.parent_id) AND d.deleted_at > l.created_at)`)
+    .map(({ id, parent }) => [id, parent]));
+//# sourceMappingURL=conversations.js.map