@wirecat/cli-core 0.400.0 → 0.401.0

package/dist/meetings/read-answers.d.ts

@@ -1,5 +1,6 @@
 import * as v from "valibot";
 import type { MeetingLink } from "./links.js";
+import type { Event } from "./model.js";
 import type { MeetingReviewItem } from "./review.js";
 import type { MeetingSpeakerStats, MeetingStats } from "./stats.js";
 /** One meeting in `review`: what the store holds about it, never transcript text. */
@@ -165,3 +166,20 @@ export declare const meetingPassage: v.StrictObjectSchema<{
         readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
     }, undefined>, undefined>;
 }, undefined>;
+/** A stored event a meeting belongs to; `id` is what `meetings update --event-id` takes. */
+export declare const event: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly event_series_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly timezone: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** `auto`: made from a meeting; `owner`: made by hand. */
+    readonly origin: v.PicklistSchema<["auto", "owner"], undefined>;
+    readonly deleted_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly updated_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+}, undefined>;
+export declare const eventItem: (one: Event) => v.InferOutput<typeof event>;

package/dist/meetings/read-answers.js

@@ -181,3 +181,33 @@ export const meetingPassage = v.strictObject({
         revision,
     })),
 });
+/** A stored event a meeting belongs to; `id` is what `meetings update --event-id` takes. */
+export const event = v.strictObject({
+    id: v.pipe(v.string(), v.minLength(1)),
+    event_series_id: v.nullable(text),
+    title: v.nullable(text),
+    description: v.nullable(text),
+    location: v.nullable(text),
+    starts_at: v.nullable(isoTime),
+    ends_at: v.nullable(isoTime),
+    timezone: v.nullable(text),
+    /** `auto`: made from a meeting; `owner`: made by hand. */
+    origin: v.picklist(["auto", "owner"]),
+    deleted_at: v.nullable(isoTime),
+    created_at: isoTime,
+    updated_at: isoTime,
+});
+export const eventItem = (one) => ({
+    id: String(one.id),
+    event_series_id: one.eventSeriesId === null ? null : String(one.eventSeriesId),
+    title: one.title,
+    description: one.description,
+    location: one.location,
+    starts_at: iso(one.startsAt),
+    ends_at: iso(one.endsAt),
+    timezone: one.timezone,
+    origin: one.origin,
+    deleted_at: iso(one.deletedAt),
+    created_at: new Date(one.createdAt).toISOString(),
+    updated_at: new Date(one.updatedAt).toISOString(),
+});

package/dist/ports/messenger.d.ts

@@ -41,7 +41,10 @@ export interface SendOptions {
     formatting?: TextSpan[];
     /** ISO time: the messenger holds it and sends it then, under a new id. */
     at?: string;
-    /** Sent in one message, `text` as the caption. More than one is an album. */
+    /**
+     * Sent in one message, `text` as the caption. More than one is an album: photos first, then files, each in the
+     * order given. An adapter whose messenger cannot send one refuses it with `validation_error` before anything goes.
+     */
     attachments?: Upload[];
     /** One sticker by id, alone: no text, no attachment. Only where `Messenger.stickers` is on. */
     sticker?: Id;
@@ -82,7 +85,13 @@ export interface NewPoll {
     closeAfter?: number;
 }
 export interface Sent {
+    /** The message sent; for an album, its first. */
     message: Message;
+    /**
+     * For an album, every message it made, in order, `message` among them. Unset for a single message, and where an
+     * adapter has not learned to answer with them yet.
+     */
+    messages?: Message[];
     /** The send's identity. Repeat it after an unknown outcome, never a new one. */
     sendId: string;
 }

package/dist/sends/guard.d.ts

@@ -12,7 +12,7 @@ export interface GuardRequest {
     chatId: Id | null;
     kind?: SendKind;
     action?: ChatAction | AccountAction;
-    /** Messages a deletion names, or people a chat change adds. */
+    /** Messages a deletion names or an album sends, or people a chat change adds. */
     count?: number;
     sendId?: string;
     sendAs?: Id;

package/dist/sends/guard.js

@@ -40,11 +40,11 @@ const countsTowardLimit = ({ kind = "message", action, notify }) => kind === "me
     action === "join" ||
     action === "contact-import";
 /**
- * Each deleted message, each person added to a group or let in by a request, and each imported number
- * counts as one.
+ * Each deleted message, each photo or file of an album (`NEED-1660`), each person added to a group or let in by a
+ * request, and each imported number counts as one.
  */
-const weightOf = ({ kind, action, count, people }) => kind === "delete"
-    ? (count ?? 1)
+const weightOf = ({ kind = "message", action, count, people }) => kind === "delete" || (kind === "message" && action === undefined)
+    ? Math.max(1, count ?? 1)
     : action === "create" || action === "members.add" || action === "requests.accept" || action === "contact-import"
         ? Math.max(1, people ?? count ?? 1)
         : 1;
@@ -180,7 +180,11 @@ export const sendGuard = ({ profile, recipients, command = recipients.command, r
                 reservation: id,
                 ...(kind ? { kind } : {}),
                 ...(action ? { action } : {}),
-                ...(asked.people === undefined ? {} : kind === "delete" ? { count: asked.people } : { people: asked.people }),
+                ...(asked.people === undefined
+                    ? {}
+                    : kind === "delete" || kind === "message" || kind === undefined
+                        ? { count: asked.people }
+                        : { people: asked.people }),
                 ...(sendId === undefined ? {} : { sendId }),
                 ...(operationId === undefined ? {} : { operationId }),
                 ...(scheduledFor ? { scheduledFor } : {}),

package/dist/sends/journal.d.ts

@@ -23,7 +23,7 @@ export interface SendEntry {
     messageId?: Id;
     /** The command a write belongs to, where it named one: `polls.create` sets a poll apart from a message. */
     key?: string;
-    /** How many messages a `delete` entry named — each one counts toward the hourly limit. */
+    /** How many messages a `delete` entry named, or an album sent — each one counts toward the hourly limit. */
     count?: number;
     forEveryone?: boolean;
     /**

package/dist/sends/permissions.d.ts

@@ -22,7 +22,7 @@ export declare const AUTHORITY_KEY: PermissionKey;
 /** Whether these levels let an agent run a command that changes what a later run may do; `ask` does, as for any write. */
 export declare const authorityAllowed: (levels: Readonly<Record<PermissionKey, Level>>) => boolean;
 /** The resources at the top of the command tree, which `readOnly` and `allow` turn read-only as a whole. */
-export declare const RESOURCES: readonly ["messages", "reactions", "polls", "topics", "chats", "contacts", "account", "bot", "conversations", "tags", "mentions", "search", "searches", "tasks", "replies", "attachments", "stats", "store", "metadata", "mcp"];
+export declare const RESOURCES: readonly ["messages", "reactions", "polls", "topics", "chats", "contacts", "account", "bot", "conversations", "tags", "mentions", "search", "searches", "tasks", "replies", "attachments", "stats", "store", "metadata", "mcp", "server", "models", "schedule", "doctor", "images"];
 /** The command path an old `allow` word stood for, as one key — what an MCP tool's `permission` is checked against. */
 export declare const keyOfWord: (word: Permission) => PermissionKey;
 /**

package/dist/sends/permissions.js

@@ -79,7 +79,27 @@ export const DEFAULT_PERMISSIONS = {
     "replies.send": "deny",
     // NEED-1662: an agent that changes settings, schedules or recipients could lift its own limits; the owner opts in.
     "mcp.authority": "deny",
+    // NEED-1663: writes no level stopped before, so MCP could not offer them; over MCP `ask` goes ahead.
+    "store.backup": "ask",
+    "store.restore": "ask",
+    "store.migrate": "ask",
+    "store.repair": "ask",
+    "store.reset": "ask",
+    "store.clear": "ask",
+    "store.decrypt": "ask",
+    "store.copies.delete": "ask",
+    "server.start": "ask",
+    "server.stop": "ask",
+    "server.restart": "ask",
+    "models.audio.download": "ask",
+    "models.text.download": "ask",
+    "images.models.download": "ask",
+    "schedule.run": "ask",
+    "schedule.exec": "ask",
+    "doctor.report.create": "ask",
 };
+/** Commands under a housekeeping word, or store maintenance, that still have a key of their own: their path. */
+const KEYED_UNDER_HOUSEKEEPING = new Set(Object.keys(DEFAULT_PERMISSIONS).filter((key) => /^(store|server|models|images|schedule|doctor)\./.test(key)));
 /** Lets an MCP server offer the commands that change what a later run may do (`grantsAuthority`). */
 export const AUTHORITY_KEY = "mcp.authority";
 /** Whether these levels let an agent run a command that changes what a later run may do; `ask` does, as for any write. */
@@ -109,6 +129,11 @@ export const RESOURCES = [
     "store",
     "metadata",
     "mcp",
+    "server",
+    "models",
+    "schedule",
+    "doctor",
+    "images",
 ];
 const OLD_WORDS = {
     send: ["messages.send", "polls.create", "chats.start"],
@@ -375,7 +400,7 @@ const HOUSEKEEPING = new Set([
 ]);
 /** Under `bot`: its token, its names, its lists and its MCP server. */
 const BOT_HOUSEKEEPING = new Set(["auth", "list", "sends", "recipients", "mcp"]);
-const STORE_MAINTENANCE = new Set(["info", "check", "migrate", "backup", "restore", "repair", "copies"]);
+const STORE_MAINTENANCE = new Set(["info", "check", "copies"]);
 /** Commands outside `messages` that print what people wrote, so `deny messages` reaches them too. */
 const SHOW_MESSAGES = new Set(["inbox", "review", "watch", "serve", "store", "conversations"]);
 /** Before every search moved under `search` (2026-10-09). */
@@ -405,6 +430,9 @@ export const readKeysForCommand = (path) => {
         return [key, "messages"];
     if (path[0] === "store" && path[1] === "gaps" && path[2] === "repair")
         return [key, "messages"];
+    // Checked as `messages` before they had keys of their own: `deny messages` keeps stopping them.
+    if (path[0] === "store" && ["reset", "clear", "decrypt"].includes(path[1] ?? ""))
+        return [key, "messages"];
     // A search shows what people wrote, so `deny messages` reaches every leaf that reads messages.
     if (path[0] === "search") {
         if (path[1] === "notes")
@@ -438,6 +466,8 @@ export const keyForCommand = (path) => {
         const inner = keyForCommand(path.slice(1));
         return `bot.${inner ?? path.slice(1).join(".")}`;
     }
+    if (KEYED_UNDER_HOUSEKEEPING.has(path.join(".")))
+        return path.join(".");
     if (top === undefined || HOUSEKEEPING.has(top) || (top === "search" && next === "runs"))
         return null;
     // Picture models moved from `models image` (0.270.0); a model is housekeeping wherever it is listed.

package/dist/sends/upload.d.ts

@@ -18,12 +18,12 @@ export declare const readUpload: (kind: UploadKind, path: string, { app, env, an
     photoTypes?: readonly string[];
 }) => Promise<Upload>;
 /**
- * What a send attaches, as `messages send` and its tool take it. A voice message goes alone, as the
- * messengers' own apps send one.
+ * What a send attaches, as `messages send` and its tool take it. More than one photo or file is an album: photos
+ * first, then files, each in the order given. A voice message goes alone, as the messengers' own apps send one.
  */
 export declare const readAttachments: ({ photo, file, voice, asFile, filename, text, }: {
-    photo?: string;
-    file?: string;
+    photo?: string | readonly string[];
+    file?: string | readonly string[];
     voice?: string;
     asFile?: boolean;
     filename?: string;

package/dist/sends/upload.js

@@ -197,37 +197,41 @@ export const readUpload = async (kind, path, { app, env = process.env, anyFile =
     }
     return { kind, name: basename(path), source: { kind: "file", path: resolve(path), size } };
 };
-const checkFilename = (filename, file) => {
-    if (file === undefined)
+const checkFilename = (filename, files) => {
+    if (files.length === 0)
         throw new CliError("validation_error", "--filename names a --file; give one");
+    if (files.length > 1)
+        throw new CliError("validation_error", "--filename names one --file; an album keeps its names");
     if (filename.trim() === "" || /[/\\\0]/.test(filename) || filename.length > 255)
         throw new CliError("validation_error", "--filename is a name, not a path: no / or \\, at most 255 characters");
 };
+const listOf = (value) => value === undefined ? [] : typeof value === "string" ? [value] : value;
 /**
- * What a send attaches, as `messages send` and its tool take it. A voice message goes alone, as the
- * messengers' own apps send one.
+ * What a send attaches, as `messages send` and its tool take it. More than one photo or file is an album: photos
+ * first, then files, each in the order given. A voice message goes alone, as the messengers' own apps send one.
  */
 export const readAttachments = async ({ photo, file, voice, asFile, filename, text, }, read) => {
-    if (voice !== undefined && (photo !== undefined || file !== undefined || (text ?? "").trim() !== "")) {
+    const photos = listOf(photo);
+    const files = listOf(file);
+    if (voice !== undefined && (photos.length > 0 || files.length > 0 || (text ?? "").trim() !== "")) {
         throw new CliError("validation_error", "a voice message goes alone — no text, no file, no photo beside it");
     }
-    if (asFile && file === undefined)
+    if (asFile && files.length === 0)
         throw new CliError("validation_error", "--as-file is about a --file; give one");
     if (filename !== undefined)
-        checkFilename(filename, file);
-    return [
-        ...(photo === undefined ? [] : [await readUpload("photo", photo, read)]),
-        ...(file === undefined
-            ? []
-            : [
-                {
-                    ...(await readUpload("file", file, read)),
-                    ...(filename === undefined ? {} : { name: filename }),
-                    ...(asFile ? { asFile: true } : {}),
-                },
-            ]),
-        ...(voice === undefined ? [] : [await readUpload("voice", voice, read)]),
-    ];
+        checkFilename(filename, files);
+    const uploads = [];
+    for (const one of photos)
+        uploads.push(await readUpload("photo", one, read));
+    for (const one of files)
+        uploads.push({
+            ...(await readUpload("file", one, read)),
+            ...(filename === undefined ? {} : { name: filename }),
+            ...(asFile ? { asFile: true } : {}),
+        });
+    if (voice !== undefined)
+        uploads.push(await readUpload("voice", voice, read));
+    return uploads;
 };
 /** A sticker to send from a file: a WebP image of at most `maxBytes`, behind the same file guard as `--file`. */
 export const readStickerFile = async (path, maxBytes, read) => {

package/dist/services/documents/mirrors.d.ts

@@ -0,0 +1,98 @@
+import type { DocumentTarget, Keep, PushStatePort } from "../../documents/push-model.js";
+import { type PushConflict, type PushOptions } from "./push.js";
+/** A local folder mirrored into a remote folder, as the app's profile config keeps it. */
+export interface Mirror {
+    id: string;
+    path: string;
+    folder: string;
+}
+export declare const mirrorId: (root: string, folder: string) => string;
+/**
+ * A mirror's sync state in `<dir>/<id>.json`. A missing file is a first sync; an unreadable or invalid one is
+ * refused rather than reset, since a reset would push every file again as new.
+ */
+export declare const fileMirrorState: <S>(dir: string, mirror: Mirror, principal: string, kinds: [string, ...string[]]) => PushStatePort<S>;
+/** What the next sync of each mirror would create or send, from local files and the state alone. */
+export declare const mirrorStatus: <S>(mirrors: Mirror[], kindOf: (path: string) => string | undefined, stateOf: (mirror: Mirror) => PushStatePort<S>) => Promise<{
+    id: string;
+    path: string;
+    folder: string;
+    create: string[];
+    update: string[];
+    unchanged: number;
+    orphans: string[];
+    unsupported: number;
+    remote_checked: boolean;
+}[]>;
+/** A conflict as the user reads it, with the remote side named the way the app names it (`google`). */
+export declare const conflictReport: (conflict: PushConflict, remote: string) => {
+    path: string;
+    url: string;
+    reason: string;
+    parts?: {
+        [x: string]: string;
+        last_sync: string;
+        local: string;
+    }[] | undefined;
+    local_changed_at?: string | undefined;
+};
+export interface MirrorSyncOptions<S> extends Pick<PushOptions<S>, "principal" | "recreate" | "guard" | "operationId" | "errorOf" | "signal"> {
+    mirrors: Mirror[];
+    target: DocumentTarget<S>;
+    stateOf(mirror: Mirror): PushStatePort<S>;
+    keep?: Keep;
+    /** Taken once for all the mirrors, so a second sync or a watcher's next cycle waits its turn. */
+    lock(): Promise<{
+        assertHeld(): void;
+        release(): Promise<void> | void;
+    }>;
+    /** How the app names the remote side in conflict reports. */
+    remote: string;
+}
+/**
+ * Syncs each mirror both ways. A mirror with conflicts, missing remote files or errors does not stop the others;
+ * it gets one `mirror.partial` issue, so the caller can answer `complete: false` and fail after printing.
+ */
+export declare const syncMirrors: <S>(options: MirrorSyncOptions<S>) => Promise<{
+    items: {
+        created: string[];
+        updated: string[];
+        pulled: string[];
+        unchanged: number;
+        missing: string[];
+        orphans: {
+            path: string;
+            url: string;
+        }[];
+        errors: {
+            path: string;
+            code: string;
+            message: string;
+        }[];
+        unsupported: number;
+        plan?: {
+            create: string[];
+            update: string[];
+            orphans: string[];
+        };
+        stopped?: true;
+        id: string;
+        path: string;
+        conflicts: {
+            path: string;
+            url: string;
+            reason: string;
+            parts?: {
+                [x: string]: string;
+                last_sync: string;
+                local: string;
+            }[] | undefined;
+            local_changed_at?: string | undefined;
+        }[];
+    }[];
+    issues: {
+        code: "provider_error";
+        reason: string;
+        source: string;
+    }[];
+}>;

package/dist/services/documents/mirrors.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CliError, writeSecurely } from "@wirecat/cli-base";
+import * as v from "valibot";
+import { planPush, pushDocuments, scanLocal } from "./push.js";
+export const mirrorId = (root, folder) => createHash("sha256")
+    .update(JSON.stringify([root, folder]))
+    .digest("hex")
+    .slice(0, 8);
+const ID = v.pipe(v.string(), v.regex(/^[A-Za-z0-9_-]{1,200}$/));
+const stateSchema = (kinds) => v.object({
+    version: v.literal(1),
+    principal: v.string(),
+    root: v.string(),
+    target: ID,
+    folders: v.record(v.string(), ID),
+    entries: v.record(v.string(), v.object({
+        id: ID,
+        url: v.string(),
+        kind: v.string(),
+        hash: v.string(),
+        // Checked by kind only: the rest is the provider's own read-back.
+        snapshot: v.looseObject({ kind: v.picklist(kinds) }),
+        pushedAt: v.string(),
+    })),
+    pending: v.record(v.string(), v.object({ origin: v.string(), operationId: v.string() })),
+});
+/**
+ * A mirror's sync state in `<dir>/<id>.json`. A missing file is a first sync; an unreadable or invalid one is
+ * refused rather than reset, since a reset would push every file again as new.
+ */
+export const fileMirrorState = (dir, mirror, principal, kinds) => {
+    const path = join(dir, `${mirror.id}.json`);
+    const schema = stateSchema(kinds);
+    return {
+        read: () => {
+            let value;
+            try {
+                value = JSON.parse(readFileSync(path, "utf8"));
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return {
+                        version: 1,
+                        principal,
+                        root: mirror.path,
+                        target: mirror.folder,
+                        folders: {},
+                        entries: {},
+                        pending: {},
+                    };
+                throw new CliError("configuration_error", "mirror state is unreadable; refusing to reset it", {
+                    reason: "state.invalid",
+                });
+            }
+            const parsed = v.safeParse(schema, value);
+            if (!parsed.success)
+                throw new CliError("configuration_error", "mirror state is invalid; refusing to reset it", {
+                    reason: "state.invalid",
+                });
+            return parsed.output;
+        },
+        save: (state) => {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            writeSecurely(path, `${JSON.stringify(state)}\n`, 0o600);
+        },
+    };
+};
+/** What the next sync of each mirror would create or send, from local files and the state alone. */
+export const mirrorStatus = async (mirrors, kindOf, stateOf) => {
+    const items = [];
+    for (const mirror of mirrors) {
+        const { files, unsupported } = await scanLocal(mirror.path, kindOf);
+        const plan = planPush(files, stateOf(mirror).read());
+        items.push({
+            id: mirror.id,
+            path: mirror.path,
+            folder: mirror.folder,
+            create: plan.create.map((file) => file.path),
+            update: plan.update.map((file) => file.path),
+            unchanged: plan.unchanged.length,
+            orphans: plan.orphans,
+            unsupported,
+            remote_checked: false,
+        });
+    }
+    return items;
+};
+/** A conflict as the user reads it, with the remote side named the way the app names it (`google`). */
+export const conflictReport = (conflict, remote) => ({
+    path: conflict.path,
+    url: conflict.url,
+    reason: conflict.reason,
+    ...(conflict.parts
+        ? { parts: conflict.parts.map((part) => ({ last_sync: part.base, local: part.local, [remote]: part.remote })) }
+        : {}),
+    ...(conflict.localChangedAt ? { local_changed_at: conflict.localChangedAt } : {}),
+    ...(conflict.remoteChangedAt ? { [`${remote}_changed_at`]: conflict.remoteChangedAt } : {}),
+    ...(conflict.remoteChangedBy ? { [`${remote}_changed_by`]: conflict.remoteChangedBy } : {}),
+});
+/**
+ * Syncs each mirror both ways. A mirror with conflicts, missing remote files or errors does not stop the others;
+ * it gets one `mirror.partial` issue, so the caller can answer `complete: false` and fail after printing.
+ */
+export const syncMirrors = async (options) => {
+    const { mirrors, keep, remote } = options;
+    const lock = await options.lock();
+    const results = [];
+    try {
+        for (const mirror of mirrors)
+            results.push({
+                id: mirror.id,
+                path: mirror.path,
+                ...(await pushDocuments({
+                    root: mirror.path,
+                    folder: mirror.folder,
+                    target: options.target,
+                    state: options.stateOf(mirror),
+                    principal: options.principal,
+                    ...(keep ? { keep } : {}),
+                    recreate: options.recreate === true,
+                    guard: options.guard,
+                    operationId: options.operationId,
+                    errorOf: options.errorOf,
+                    assertHeld: () => lock.assertHeld(),
+                    ...(options.signal ? { signal: options.signal } : {}),
+                })),
+            });
+    }
+    finally {
+        await lock.release();
+    }
+    const issues = results
+        .filter((result) => result.errors.length || result.conflicts.length || result.missing.length)
+        .map((result) => ({ code: "provider_error", reason: "mirror.partial", source: `mirror ${result.id}` }));
+    return {
+        items: results.map(({ conflicts, ...result }) => ({
+            ...result,
+            conflicts: conflicts.map((conflict) => conflictReport(conflict, remote)),
+        })),
+        issues,
+    };
+};

package/dist/services/messages.js

@@ -283,6 +283,7 @@ export const messagesService = (deps) => {
                 sendId: id,
                 operationId: id,
                 length: text.length,
+                ...(attachments.length > 1 ? { count: attachments.length } : {}),
                 ...(replyTo === undefined ? {} : { replyTo }),
                 ...(threadId === undefined ? {} : { threadId }),
                 ...(sendAs === undefined ? {} : { sendAs }),

package/dist/services/search-all-meetings.js

@@ -4,6 +4,7 @@ import { formatMeetingReference } from "../meetings/index.js";
 import { entriesOfList, fitting } from "../search/account-list.js";
 import { SEARCH_QUERY } from "../search/lucene/types.js";
 import { codeOf } from "../sends/guarded.js";
+import { MAX_SEARCH_OFFSET } from "./messages-archive-search.js";
 import { RRF_K } from "./notes-search.js";
 import { RESOURCES_SEARCHED, searchAll, } from "./search-all.js";
 import { listContextOf } from "./search-kind.js";
@@ -139,26 +140,35 @@ export const searchAllIncludingMeetings = async (store, account, request, messen
         whole(request.meetingCursor.hitOffset, 0, Number.MAX_SAFE_INTEGER, "cursor hit offset");
     }
     cancelled(request.signal);
-    const legacy = await searchAll(store, account, { ...request, only: only.filter((one) => one !== "meetings") }, messenger, searchMessages);
+    const others = { ...request, only: only.filter((one) => one !== "meetings") };
+    if (!only.includes("meetings")) {
+        const found = await searchAll(store, account, others, messenger, searchMessages);
+        cancelled(request.signal);
+        return found;
+    }
+    // Meetings rank with the rest, so a later page is the same merge read deeper, then cut.
+    const offset = request.offset ?? 0;
+    const window = offset + request.limit;
+    const legacy = await searchAll(store, account, { ...others, offset: 0, limit: window }, messenger, searchMessages);
     cancelled(request.signal);
-    if (!only.includes("meetings"))
-        return legacy;
     const compiled = meetingQuery(request.text, request.exact);
     if ("reason" in compiled)
         return {
             ...legacy,
+            items: legacy.items.slice(offset),
             skipped: [...legacy.skipped, { resource: "meetings", code: "validation_error", reason: compiled.reason }],
         };
     let meetings;
     const meetingAccount = request.meetingAccount ?? account;
     try {
-        meetings = await collectMeetings(store, meetingAccount, request, compiled.query);
+        meetings = await collectMeetings(store, meetingAccount, { ...request, limit: window }, compiled.query);
     }
     catch (error) {
         if (codeOf(error) !== "not_found")
             throw error;
         return {
             ...legacy,
+            items: legacy.items.slice(offset),
             skipped: [
                 ...legacy.skipped,
                 { resource: "meetings", code: "not_found", reason: "the selected meeting account is not stored" },
@@ -176,13 +186,16 @@ export const searchAllIncludingMeetings = async (store, account, request, messen
             ranked.set(key, held);
         });
     const ordered = [...ranked.values()].sort((a, b) => b.score - a.score).map(({ item }) => item);
-    const items = ordered.slice(0, request.limit);
-    const returnedMeetings = items.filter((item) => item.kind === "meeting").length;
+    const items = ordered.slice(offset, window);
+    const returnedMeetings = ordered.slice(0, window).filter((item) => item.kind === "meeting").length;
     const nextCursor = meetings.items[returnedMeetings]?.before ?? (!meetings.coverage.complete ? meetings.after : undefined);
+    const more = legacy.hasMore || ordered.length > window;
+    const { nextOffset: _, ...rest } = legacy;
     return {
-        ...legacy,
+        ...rest,
         items,
-        hasMore: legacy.hasMore || ordered.length > request.limit ? true : meetings.coverage.complete ? false : null,
+        hasMore: more ? true : meetings.coverage.complete ? false : null,
+        ...(more && window <= MAX_SEARCH_OFFSET ? { nextOffset: window } : {}),
         searched: [...legacy.searched, "meetings"],
         accounts: [
             ...legacy.accounts,

package/dist/services/task-rules.d.ts

@@ -5,7 +5,7 @@ import { type TaskCategory } from "./task-categories.js";
 export interface RuleResult {
     added: number;
     closed: number;
-    /** Opened tasks that may be the same job as another: on the review list (`tasks duplicates`). */
+    /** Opened tasks that may be the same job as another: on the review list (`tasks duplicates list`). */
     review: number;
     /** Tasks the rules found but did not open: over the per-chat limit, or a dry run. */
     held?: number;

package/dist/services/tasks.d.ts

@@ -26,7 +26,7 @@ export declare const TASK_QUERY: {
     readonly backend: "sql";
     readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
 };
-/** Which pairs `tasks duplicates` lists: those waiting for the reviewing agent, or those it left to the owner. */
+/** Which pairs `tasks duplicates list` lists: those waiting for the reviewing agent, or those it left to the owner. */
 export declare const PAIR_DECISIONS: readonly ["review", "unsure"];
 export type PairDecision = (typeof PAIR_DECISIONS)[number];
 export declare const TASK_PAIR_QUERY: {
@@ -168,7 +168,7 @@ export interface TasksService {
     /**
      * Links a task to stored things (`msg:`, `chat:`, `person:`, `document:`…) or, for what the store does
      * not hold, to the text as written — a URL, a message not saved yet. After a `msg:` target, `review` counts the
-     * pairs the duplicate check sent to `tasks duplicates`.
+     * pairs the duplicate check sent to `tasks duplicates list`.
      */
     link(id: string, targets: {
         references?: readonly string[];