@wirecat/cli-core 0.552.0 → 0.554.0

package/dist/services/stored-project-gathering.d.ts

@@ -1,7 +1,8 @@
 import type { ContextSource } from "../context/evidence.js";
-import type { MessageStore } from "../store/store.js";
+import type { AccountKey, MessageStore } from "../store/store.js";
 import { gatherProjectEvidence, type ProjectChatFetcher, type ProjectGatheringPorts } from "./project-gathering.js";
 import { type EvidenceMentions } from "./project-gathering-mentions.js";
+import { type PurposeConfig } from "./project-purposes.js";
 export interface StoredProjectInput {
     project: string;
     /** The sources the host resolved from its `--source`, and those it could not read. */
@@ -31,19 +32,81 @@ export interface StoredProjectInput {
     maxFetchMs?: number;
     onFetchProgress?: ProjectGatheringPorts["onFetchProgress"];
     signal?: AbortSignal;
+    /** The linked chats' purposes to read; `["all"]` reads every one. Left out, the config's defaults. */
+    purposes?: readonly string[];
+    /** The host's purposes; core's built-in ones when left out. */
+    purposeConfig?: PurposeConfig;
+    /** Proposed `member-of` links count as linked chats and members too, after the confirmed ones, every item marked. */
+    includeProposed?: boolean;
+    /** How many messages a left-out chat holds in the window; the store's own count when left out. */
+    count?: ChatCounter;
 }
+export interface ChatCount {
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
+}
+export type ChatCounter = (account: AccountKey, chatId: string, window: {
+    since: number;
+    until: number;
+}) => Promise<ChatCount>;
+/** The store's count of one chat's messages in a window, `until` exclusive, and the first and last of them. */
+export declare const storedChatCount: (store: MessageStore) => ChatCounter;
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export declare const canonicalProjectRef: (store: MessageStore, reference: string) => Promise<string>;
+export interface ProjectMember {
+    person: string;
+    state: "read" | "member-limit" | "no-identity";
+    /** The proposal that names this person a member; read only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
 export interface LinkedChat {
     provider: string;
     account: string;
     chat: string;
     /** The link's free role (`source report`, `what worked`), if the owner set one. */
     role: string | null;
+    /** What the chat is for in the project; `null` means `work`. */
+    purpose: string | null;
+    /** The confirmed link's id; null for a proposed one. */
+    relationship: string | null;
+    /** The proposal that links the chat; only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
+/**
+ * Links the owner confirmed, then, when asked, the proposed ones: a suggestion would put a whole chat into the
+ * evidence on a guess, so it is read only on request and marked.
+ */
+export declare const linkedChatsOf: (store: MessageStore, project: string | null, options?: {
+    includeProposed?: boolean;
+}) => Promise<LinkedChat[]>;
+/** A linked chat whose purpose this run did not read: counted, never listed. */
+export interface LeftOutChat {
+    ref: string;
+    provider: string;
+    account: string;
+    chat: string;
+    title: string | null;
+    purpose: string;
+    relationship: string | null;
+    proposed?: string;
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
 }
-/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-export declare const linkedChatsOf: (store: MessageStore, project: string | null) => Promise<LinkedChat[]>;
-export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>> & {
+type Gathered = Awaited<ReturnType<typeof gatherProjectEvidence>>;
+export type StoredProjectGathering = Omit<Gathered, "items" | "linkedChats"> & {
+    /** `proposed`: the proposal whose link alone brought the item in; only with `includeProposed`. */
+    items: (Gathered["items"][number] & {
+        proposed?: string;
+    })[];
+    linkedChats: (Gathered["linkedChats"][number] & {
+        purpose: string;
+        proposed?: string;
+        score?: number;
+    })[];
     projectRef: string | null;
     unreadSources: {
         source: string;
@@ -51,9 +114,21 @@ export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvid
         reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
     }[];
     mentions: EvidenceMentions;
+    /** The purposes read: `all`, or the list. */
+    purposes: "all" | string[];
+    leftOut: LeftOutChat[];
+    members: ProjectMember[];
+    /** One linked chat with no purpose set gave most of this run's items; a first run only, so it is said once. */
+    purposeHint: {
+        chat: string;
+        relationship: string;
+        items: number;
+        of: number;
+    } | null;
 };
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
  * confirmed person members and its confirmed linked chats, in the sources the host resolved.
  */
 export declare const gatherStoredProject: (store: MessageStore, input: StoredProjectInput) => Promise<StoredProjectGathering>;
+export {};

package/dist/services/stored-project-gathering.js

@@ -4,6 +4,21 @@ import { chatCoverage } from "./chat-coverage.js";
 import { gatherProjectEvidence } from "./project-gathering.js";
 import { storedNeighbours } from "./project-gathering-around.js";
 import { findEvidenceMentions } from "./project-gathering-mentions.js";
+import { LINK_PURPOSE, purposeRead, purposesOf } from "./project-purposes.js";
+/** The store's count of one chat's messages in a window, `until` exclusive, and the first and last of them. */
+export const storedChatCount = (store) => async (account, chatId, { since, until }) => {
+    const window = { since: new Date(since).toISOString(), until: new Date(until - 1).toISOString() };
+    const [messages, newest, oldest] = await Promise.all([
+        store.messages.countMessages(account, chatId, window),
+        store.messages.messages(account, chatId, { limit: 1, since: window.since, until: until - 1 }),
+        store.messages.messages(account, chatId, { limit: 1, after: { time: since - 1 }, until: until - 1 }),
+    ]);
+    return {
+        messages,
+        firstAt: oldest.items[0]?.timestamp ?? null,
+        lastAt: newest.items.at(-1)?.timestamp ?? null,
+    };
+};
 const PROJECT_ID = /^project:[1-9]\d*$/;
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export const canonicalProjectRef = async (store, reference) => {
@@ -85,59 +100,122 @@ const contactOf = async (store, contact) => {
 };
 const LINKED_CHATS = 16;
 const CORE_LIMIT = 16;
-/** Confirmed `person` members, in a stable order, so a cut at the lane limit always drops the same ones. */
-const memberRefsOf = async (store, project) => {
+/** Pending `member-of` proposals to the project, oldest first, so a cut at a limit always drops the same ones. */
+const proposedLinksOf = async (store, project) => {
+    const stored = await store.proposedActions.list({ kinds: ["relationship"], status: "proposed", project, limit: 500 });
+    const proposals = stored
+        .flatMap((action) => {
+        const payload = action.payload;
+        const { purpose, score } = action.payload;
+        if (payload?.kind !== "member-of" || payload.to !== project || typeof payload.from !== "string")
+            return [];
+        return [
+            {
+                from: payload.from,
+                id: action.id,
+                role: typeof payload.role === "string" ? payload.role : null,
+                purpose: typeof purpose === "string" ? purpose : null,
+                ...(typeof score === "number" ? { score } : {}),
+            },
+        ];
+    })
+        .sort((a, b) => Number(a.id) - Number(b.id));
+    const legacy = (await store.knowledge.relations(null, project))
+        .filter((one) => !one.confirmed && one.kind === "member-of" && one.to === project)
+        .map((one) => ({ from: one.from, id: `link:${one.id}`, role: one.role, purpose: one.purpose }));
+    return [...proposals, ...legacy];
+};
+/** Confirmed `person` members in a stable order, then proposed ones when asked, so a cut drops the same ones. */
+const memberRefsOf = async (store, project, includeProposed) => {
     if (!project)
         return [];
-    const refs = [];
+    const confirmed = new Set();
     for (const relation of await store.knowledge.relations(null, project))
         if (relation.confirmed &&
             relation.kind === "member-of" &&
             relation.to === project &&
             /^person:.+/.test(relation.from))
-            refs.push(relation.from);
-    return [...new Set(refs)].sort();
+            confirmed.add(relation.from);
+    const members = [...confirmed].sort().map((ref) => ({ ref }));
+    if (!includeProposed)
+        return members;
+    for (const one of await proposedLinksOf(store, project))
+        if (/^person:.+/.test(one.from) && !members.some((member) => member.ref === one.from))
+            members.push({ ref: one.from, proposed: one.id, ...(one.score === undefined ? {} : { score: one.score }) });
+    return members;
 };
 /**
  * Members are read by what their identities wrote, like `--contact person:<id>` but without the owner's aliases:
  * a short alias would add a text lane that matches mentions, and membership is about who wrote, not who was named.
  */
-const memberLanesOf = async (store, project, given, room) => {
+const memberLanesOf = async (store, project, given, room, includeProposed) => {
     const lanes = [];
     const left = [];
-    for (const reference of (await memberRefsOf(store, project)).filter((one) => !given.has(one))) {
+    const rows = [];
+    for (const member of (await memberRefsOf(store, project, includeProposed)).filter((one) => !given.has(one.ref))) {
+        const { ref: reference, ...marks } = member;
         const person = await store.people.personByUid(reference.slice("person:".length));
         const senders = person ? sendersOf(person) : [];
-        if (!senders.length)
-            left.push({ source: reference, kind: "member", reason: "no-identity" });
-        else if (lanes.length >= room)
-            left.push({ source: reference, kind: "member", reason: "member-limit" });
-        else
+        const state = !senders.length ? "no-identity" : lanes.length >= room ? "member-limit" : "read";
+        if (state === "read")
             lanes.push({ reference, senders });
+        else
+            left.push({ source: reference, kind: "member", reason: state });
+        rows.push({ person: reference, state, ...marks });
     }
-    return { lanes, left };
+    return { lanes, left, rows };
 };
-/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-export const linkedChatsOf = async (store, project) => {
+const chatOf = (from) => {
+    if (!from.startsWith("chat:"))
+        return undefined;
+    const reference = parseReference(from);
+    return reference.type === "chat" ? reference : undefined;
+};
+/**
+ * Links the owner confirmed, then, when asked, the proposed ones: a suggestion would put a whole chat into the
+ * evidence on a guess, so it is read only on request and marked.
+ */
+export const linkedChatsOf = async (store, project, options = {}) => {
     if (!project)
         return [];
     const chats = [];
     for (const relation of await store.knowledge.relations(null, project)) {
         if (!relation.confirmed || relation.kind !== "member-of" || relation.to !== project)
             continue;
-        if (!relation.from.startsWith("chat:"))
-            continue;
-        const reference = parseReference(relation.from);
-        if (reference.type === "chat")
+        const reference = chatOf(relation.from);
+        if (reference)
             chats.push({
                 provider: reference.provider,
                 account: reference.account,
                 chat: reference.chat,
                 role: relation.role,
+                purpose: relation.purpose,
+                relationship: relation.id,
             });
     }
+    if (!options.includeProposed)
+        return chats;
+    for (const one of await proposedLinksOf(store, project)) {
+        const reference = chatOf(one.from);
+        if (!reference)
+            continue;
+        if (chats.some((chat) => chat.provider === reference.provider && chat.account === reference.account && chat.chat === reference.chat))
+            continue;
+        chats.push({
+            provider: reference.provider,
+            account: reference.account,
+            chat: reference.chat,
+            role: one.role,
+            purpose: one.purpose,
+            relationship: null,
+            proposed: one.id,
+            ...(one.score === undefined ? {} : { score: one.score }),
+        });
+    }
     return chats;
 };
+/** Over half the items and at least this many, from one chat's membership alone: worth asking what the chat is for. */
+const HINT_ITEMS = 20;
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
  * confirmed person members and its confirmed linked chats, in the sources the host resolved.
@@ -160,9 +238,12 @@ export const gatherStoredProject = async (store, input) => {
         (input.keywords?.length ?? 0) +
         contacts.filter((one) => one.name).length;
     const room = Math.min(CORE_LIMIT - contacts.length, CORE_LIMIT - searchLanes - contacts.filter((one) => one.senders).length);
-    const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room);
+    const includeProposed = input.includeProposed === true;
+    const purposes = purposesOf(input.purposes, input.purposeConfig, project);
+    const members = await memberLanesOf(store, project.ref, new Set(contacts.flatMap((one) => one.reference ?? [])), room, includeProposed);
     const people = [...contacts, ...members.lanes];
-    const linked = await linkedChatsOf(store, project.ref);
+    const all = await linkedChatsOf(store, project.ref, { includeProposed });
+    const linked = all.filter((one) => purposeRead(purposes, one.purpose));
     const linkedChats = linked.slice(0, LINKED_CHATS).map(({ provider, account, chat }) => ({ provider, account, chat }));
     const budgets = {
         ...(input.maxReads === undefined ? {} : { maxReads: input.maxReads }),
@@ -208,5 +289,73 @@ export const gatherStoredProject = async (store, input) => {
             reason: "linked-chat-limit",
         })),
     ];
-    return { projectRef: project.ref, unreadSources: [...unread, ...unreadChats, ...members.left], ...gathered, mentions };
+    const refOf = (one) => formatReference({ type: "chat", ...one });
+    const byRef = new Map(linked.map((one) => [refOf(one), one]));
+    const proposedLanes = new Map();
+    for (const row of gathered.linkedChats) {
+        const proposed = byRef.get(row.ref)?.proposed;
+        if (proposed && row.lane !== null)
+            proposedLanes.set(row.lane, proposed);
+    }
+    for (const lane of gathered.lanes) {
+        const proposed = members.rows.find((one) => one.proposed && lane.people.includes(one.person))?.proposed;
+        if (proposed && lane.kinds.includes("sender"))
+            proposedLanes.set(lane.id, proposed);
+    }
+    // Marked only when nothing but proposed links found it: an item a word or a confirmed link found is evidence anyway.
+    const items = gathered.items.map((item) => {
+        const proposed = item.lanes.every((lane) => proposedLanes.has(lane))
+            ? proposedLanes.get(item.lanes[0] ?? "")
+            : undefined;
+        return proposed ? { ...item, proposed } : item;
+    });
+    const linkedRows = gathered.linkedChats.map((row) => {
+        const link = byRef.get(row.ref);
+        return {
+            ...row,
+            purpose: link?.purpose ?? LINK_PURPOSE,
+            ...(link?.proposed ? { proposed: link.proposed } : {}),
+            ...(link?.score === undefined ? {} : { score: link.score }),
+        };
+    });
+    const count = input.count ?? storedChatCount(store);
+    const leftOut = [];
+    for (const one of all.filter((chat) => !purposeRead(purposes, chat.purpose))) {
+        const account = { provider: one.provider, account: one.account };
+        const [counted, [held]] = await Promise.all([
+            count(account, one.chat, { since: gathered.window.after, until: gathered.window.before }),
+            chatCoverage(store, account, [one.chat]),
+        ]);
+        leftOut.push({
+            ref: refOf(one),
+            provider: one.provider,
+            account: one.account,
+            chat: one.chat,
+            title: held?.title ?? null,
+            purpose: one.purpose ?? LINK_PURPOSE,
+            relationship: one.relationship,
+            ...(one.proposed ? { proposed: one.proposed } : {}),
+            ...counted,
+        });
+    }
+    return {
+        projectRef: project.ref,
+        unreadSources: [...unread, ...unreadChats, ...members.left],
+        ...gathered,
+        items,
+        linkedChats: linkedRows,
+        mentions,
+        purposes: purposes === "all" ? "all" : [...purposes],
+        leftOut,
+        members: members.rows,
+        purposeHint: gathered.resumed ? null : purposeHintOf(linked, linkedRows, items.length),
+    };
+};
+const purposeHintOf = (linked, rows, of) => {
+    const [top] = [...rows].sort((a, b) => (b.items ?? 0) - (a.items ?? 0));
+    const items = top?.items ?? 0;
+    const link = linked.find((one) => formatReference({ type: "chat", ...one }) === top?.ref);
+    if (!top || !link?.relationship || link.purpose !== null || items < HINT_ITEMS || items * 2 <= of)
+        return null;
+    return { chat: top.ref, relationship: link.relationship, items, of };
 };

package/dist/store/messages.d.ts

@@ -45,9 +45,10 @@ export interface AccountMessages {
      * ends the window; `reads.MessagePageWindow` says how.
      */
     messages(key: AccountKey, chatId: Id, window: reads.MessagePageWindow): Promise<Page<Message>>;
-    /** How many stored messages the chat has, sent at `since` or later when it is given. */
+    /** How many stored messages the chat has, sent at `since` or later and at `until` or earlier when given. */
     countMessages(key: AccountKey, chatId: Id, options?: {
         since?: string;
+        until?: string;
     }): Promise<number>;
     /** Saved or edited after `at` (ISO, this machine's clock), oldest first, and the ids deleted after it. */
     changes(key: AccountKey, chatId: Id, at: string): Promise<{

package/dist/store/messages.js

@@ -32,9 +32,9 @@ export const accountMessagesOver = (context) => {
             const chatKey = chatKeyOf(key, chatId);
             return chatKey === undefined ? { items: [], hasMore: false } : reads.messagePage(context, chatKey, window);
         },
-        countMessages: async (key, chatId, { since } = {}) => {
+        countMessages: async (key, chatId, { since, until } = {}) => {
             const chatKey = chatKeyOf(key, chatId);
-            return chatKey === undefined ? 0 : reads.countMessages(context, chatKey, since);
+            return chatKey === undefined ? 0 : reads.countMessages(context, chatKey, since, until);
         },
         changes: async (key, chatId, at) => {
             const chatKey = chatKeyOf(key, chatId);

package/dist/store/sqlite/email-locations.d.ts

@@ -59,3 +59,4 @@ export declare const partialMail: (database: CacheDatabase) => PartialMailStore;
 export declare const storedWhole: (database: CacheDatabase, emailId: number) => boolean;
 export declare const setLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, found: ReadonlyMap<string, number[]>) => number;
 export declare const forgetLocations: (database: CacheDatabase, accountId: number, folder: string, uidvalidity: string, uids: number[]) => void;
+export declare const backfillSentAt: (database: CacheDatabase, accountId: number, limit: number) => number;

package/dist/store/sqlite/email-locations.js

@@ -107,3 +107,7 @@ export const forgetLocations = (database, accountId, folder, uidvalidity, uids)
     for (const emailId of new Set(emails))
         leave.run(emailId, Number(box.id), emailId, Number(box.id));
 };
+export const backfillSentAt = (database, accountId, limit) => Number(database
+    .prepare(`UPDATE emails SET sent_at = received_at WHERE id IN (
+           SELECT id FROM emails WHERE account_id = ? AND sent_at IS NULL AND received_at IS NOT NULL LIMIT ?)`)
+    .run(accountId, limit).changes);

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

@@ -238,6 +238,8 @@ export interface MailStore extends PartialMailStore {
         read?: boolean;
         flagged?: boolean;
     }>, now: number): Promise<number>;
+    /** Gives up to `limit` emails stored without `sent_at` their internal date; answers how many. */
+    backfillSentAt(accountId: number, limit: number): Promise<number>;
     /** The live emails whose location in `folder` has this UIDVALIDITY, oldest UID first. */
     folderEmails(accountId: number, folder: string, uidvalidity: string): Promise<FolderEmail[]>;
     /**

package/dist/store/sqlite/emails.js

@@ -2,7 +2,7 @@ import { formatLocator } from "../../domain/locator.js";
 import { formatReference } from "../../domain/references.js";
 import { fold, normalize } from "../normalize.js";
 import { chunkAttachments, drainEmailIndex, dropAttachmentChunks, MAIL_PIECES, queueThreads, threadPieces, titleOf, } from "./email-index.js";
-import { folderEmails, forgetLocations, locate, partialMail, setLocations, storedWhole, } from "./email-locations.js";
+import { backfillSentAt, folderEmails, forgetLocations, locate, partialMail, setLocations, storedWhole, } from "./email-locations.js";
 import { markEmailsDeleted, markEmailsRestored, recountEmailThread as recount, setEmailFlags } from "./email-state.js";
 import { bool, flag, fromJson, int, page, str, toJson } from "./events.js";
 import { folded } from "./folded.js";
@@ -554,11 +554,8 @@ export const mailStoreOver = ({ database, orm, now }, stemmerFor = stemmerCache(
             return count;
         });
     },
-    async setFlags(accountId, flags, now) {
-        return write(database, () => {
-            return setEmailFlags(database, accountId, flags, now);
-        });
-    },
+    setFlags: async (accountId, flags, now) => write(database, () => setEmailFlags(database, accountId, flags, now)),
+    backfillSentAt: async (accountId, limit) => write(database, () => backfillSentAt(database, accountId, limit)),
     folderEmails: async (accountId, folder, uidvalidity) => folderEmails(database, accountId, folder, uidvalidity),
     setLocations: async (accountId, folder, uidvalidity, found) => write(database, () => setLocations(database, accountId, folder, uidvalidity, found)),
     forgetLocations: async (accountId, folder, uidvalidity, uids) => write(database, () => forgetLocations(database, accountId, folder, uidvalidity, uids)),

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

@@ -882,7 +882,7 @@ export declare const selectMessages: ({ orm }: StoreContext) => Omit<import("dri
 export declare const newestFirst: SQL<unknown>[];
 export declare const before: (sentAt: number, pk: number) => SQL<unknown>;
 export declare const toMessages: ({ orm }: StoreContext, rows: MessageRow[]) => Message[];
-export declare const countMessages: ({ orm }: StoreContext, chatKey: number, since: string | undefined) => number;
+export declare const countMessages: ({ orm }: StoreContext, chatKey: number, since: string | undefined, until?: string) => number;
 /**
  * What changed in a chat after `at`, a time on this machine's clock: messages first saved or edited
  * since, oldest first, and the ids deleted since. Send time cannot answer it — an edit made today to

package/dist/store/sqlite/reads.js

@@ -51,10 +51,10 @@ export const toMessages = ({ orm }, rows) => {
     }
     return rows.map((row) => toMessage(row, byMessage.get(row.pk) ?? []));
 };
-export const countMessages = ({ orm }, chatKey, since) => Number(orm
+export const countMessages = ({ orm }, chatKey, since, until) => Number(orm
     .select({ n: sql `count(*)` })
     .from(messages)
-    .where(live(chatKey, since === undefined ? undefined : gte(messages.sentAt, toMs(since))))
+    .where(live(chatKey, since === undefined ? undefined : gte(messages.sentAt, toMs(since)), until === undefined ? undefined : lte(messages.sentAt, toMs(until))))
     .get()?.n);
 /**
  * What changed in a chat after `at`, a time on this machine's clock: messages first saved or edited

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.552.0",
+  "version": "0.554.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -478,6 +478,9 @@
       "meaning": "every chat of these kinds, comma-separated",
       "note": "a folder (`chats folders`) or an export folder (`store export`) takes these chats"
     },
+    "--include-proposed": {
+      "meaning": "also read chats and members proposed for the project and not yet confirmed, each item marked"
+    },
     "--into": {
       "value": "<id>",
       "meaning": "the task that stays: a duplicate is merged into it, or a message is linked to it instead of opening a task"
@@ -832,6 +835,10 @@
       "value": "<url>",
       "meaning": "the tunnel's https address: the browser apps reach mcp serve --http through it, a messenger delivers to bot watch"
     },
+    "--purpose": {
+      "value": "<purposes>",
+      "meaning": "the linked chats' purposes to read, comma-separated, or all; a chat left out is counted"
+    },
     "--question": {
       "meaning": "match only questions"
     },
@@ -3707,9 +3714,11 @@
         "--contact": "all",
         "--context-query": "all",
         "--cursor": "all",
+        "--include-proposed": "all",
         "--limit": "all",
         "--max-pages": "all",
         "--no-catch-up": "all",
+        "--purpose": "all",
         "--since-time": "all",
         "--sync-first": "all",
         "--sync-time": "all"
@@ -3723,6 +3732,7 @@
       "options": {
         "--before-time": "all",
         "--context-query": "all",
+        "--purpose": "all",
         "--since-time": "all"
       }
     },