@wirecat/cli-core 0.399.0 → 0.401.0

package/dist/meetings/read-answers.js

@@ -0,0 +1,213 @@
+import { isoTime, reference } from "@wirecat/cli-base/standards";
+import * as v from "valibot";
+import { formatMeetingReference } from "./reference.js";
+const text = v.string();
+const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+const id = v.pipe(v.number(), v.integer(), v.minValue(1));
+const iso = (ms) => (ms === null ? null : new Date(ms).toISOString());
+const meetingRef = (accountId, meetingId) => formatMeetingReference({ type: "meeting", accountId, meetingId });
+/** One meeting in `review`: what the store holds about it, never transcript text. */
+export const meetingReview = v.strictObject({
+    ref: reference,
+    id: v.pipe(v.string(), v.minLength(1)),
+    title: v.nullable(text),
+    started_at: v.nullable(isoTime),
+    duration_ms: v.nullable(count),
+    participants_count: v.nullable(count),
+    projects: v.array(text),
+    /** Null when the meeting has no current transcript. */
+    transcript: v.nullable(v.strictObject({ lines: count, words: count })),
+    /** The three who talked longest. */
+    speakers: v.array(v.strictObject({ name: v.nullable(text), talk_ms: count })),
+    /** The newest stored summary; null when there is none. */
+    summary: v.nullable(v.strictObject({
+        source: text,
+        title: v.nullable(text),
+        overview: v.nullable(text),
+        next_steps: v.array(text),
+        url: v.nullable(text),
+    })),
+});
+export const meetingReviewItem = (one) => ({
+    ref: meetingRef(one.accountId, one.meetingId),
+    id: String(one.meetingId),
+    title: one.title,
+    started_at: iso(one.startedAt),
+    duration_ms: one.durationMs,
+    participants_count: one.participantsCount,
+    projects: one.projects,
+    transcript: one.transcript,
+    speakers: one.speakers.map((speaker) => ({ name: speaker.name, talk_ms: speaker.talkMs })),
+    summary: one.summary && {
+        source: one.summary.source,
+        title: one.summary.title,
+        overview: one.summary.overview,
+        next_steps: one.summary.nextSteps,
+        url: one.summary.url,
+    },
+});
+/** A link shared in meeting chat, with where and how often; `mentions list` answers these. */
+export const meetingLink = v.strictObject({
+    url: text,
+    domain: v.nullable(text),
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    document_id: v.nullable(text),
+    count,
+    first_at: isoTime,
+    last_at: isoTime,
+    senders: v.array(text),
+    meetings: v.array(v.strictObject({ ref: reference, title: v.nullable(text) })),
+});
+export const meetingLinkItem = (link) => ({
+    url: link.url,
+    domain: link.domain,
+    document_id: link.documentId,
+    count: link.count,
+    first_at: new Date(link.firstAt).toISOString(),
+    last_at: new Date(link.lastAt).toISOString(),
+    senders: link.senders,
+    meetings: link.meetings.map((one) => ({ ref: meetingRef(one.accountId, one.meetingId), title: one.title })),
+});
+/** One speaker's talk over the selected meetings; `stats meetings top` answers these. */
+export const meetingSpeaker = v.strictObject({
+    /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+    key: text,
+    name: v.nullable(text),
+    person_id: v.nullable(id),
+    identity_id: v.nullable(id),
+    meetings: count,
+    lines: count,
+    words: count,
+    talk_ms: count,
+    /** This speaker's part of all talk time, 0–1. */
+    share: v.pipe(v.number(), v.minValue(0), v.maxValue(1)),
+});
+export const meetingSpeakerItem = (one) => ({
+    key: one.key,
+    name: one.name,
+    person_id: one.personId,
+    identity_id: one.identityId,
+    meetings: one.meetings,
+    lines: one.lines,
+    words: one.words,
+    talk_ms: one.talkMs,
+    share: one.share,
+});
+/** `stats meetings show`: how much was said over the selected meetings, by week, with the top speakers. */
+export const meetingStats = v.strictObject({
+    time_zone: text,
+    meetings: count,
+    lines: count,
+    words: count,
+    talk_ms: count,
+    /** `week_start` is the Monday, as a date in `time_zone`. */
+    weeks: v.array(v.strictObject({ week_start: text, meetings: count, talk_ms: count })),
+    top_speakers: v.array(meetingSpeaker),
+});
+export const meetingStatsItem = (found, top = 10) => ({
+    time_zone: found.timeZone,
+    meetings: found.meetings,
+    lines: found.lines,
+    words: found.words,
+    talk_ms: found.talkMs,
+    weeks: found.weeks.map((week) => ({ week_start: week.weekStart, meetings: week.meetings, talk_ms: week.talkMs })),
+    top_speakers: found.speakers.slice(0, top).map(meetingSpeakerItem),
+});
+const truncated = (...why) => v.nullable(v.picklist(why));
+/** `meetings people`: one page of participant observations whose name or email matches. */
+export const meetingParticipants = v.strictObject({
+    schema_version: v.literal(1),
+    kind: v.literal("meeting_participants"),
+    account_id: id,
+    query: text,
+    items: v.array(v.strictObject({
+        participant_id: id,
+        meeting_id: id,
+        identity_id: id,
+        display_name: v.nullable(text),
+        email: v.nullable(text),
+    })),
+    /** Several identities on one page are observations, never speaker attribution or person links. */
+    ambiguity: v.strictObject({ scope: v.literal("page"), multiple_identities: v.boolean(), identity_ids: v.array(id) }),
+    coverage: v.strictObject({
+        scanned: count,
+        read_bytes: count,
+        archive_completeness: v.literal("unknown"),
+        truncated_by: truncated("limit", "scan_limit", "read_bytes"),
+    }),
+    page: v.strictObject({
+        mode: v.literal("cursor"),
+        limit: count,
+        has_more: v.boolean(),
+        next_cursor: v.optional(text),
+    }),
+});
+const revision = v.picklist(["current", "superseded"]);
+/** `meetings passage`: a transcript line with the lines around it. */
+export const meetingPassage = v.strictObject({
+    schema_version: v.literal(1),
+    kind: v.literal("meeting_context"),
+    source: reference,
+    target_ref: reference,
+    target_fingerprint: text,
+    fingerprint: text,
+    revision,
+    limits: v.strictObject({ before: count, after: count, bytes: count, max_read_bytes: count }),
+    content_bytes: count,
+    coverage: v.strictObject({
+        included: count,
+        before: count,
+        after: count,
+        has_before: v.boolean(),
+        has_after: v.boolean(),
+        truncated_by: truncated("bytes"),
+        before_ref: v.nullable(reference),
+        after_ref: v.nullable(reference),
+        continuation: v.literal("anchor-inclusive"),
+        archive_completeness: v.literal("unknown"),
+        input: v.literal("bounded-meeting-context"),
+    }),
+    items: v.array(v.strictObject({
+        ref: reference,
+        fingerprint: text,
+        transcript_id: id,
+        content_hash: v.nullable(text),
+        position: count,
+        start_ms: count,
+        end_ms: count,
+        speaker_participant_id: v.nullable(id),
+        speaker_name: v.nullable(text),
+        text,
+        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/runs/run.d.ts

@@ -87,7 +87,7 @@ export declare const runsDirFor: (app: AppIdentity, env?: NodeJS.ProcessEnv) =>
  * `run.json` is written **now**, with `status: "running"`, and again by `finish`. A directory
  * holding events and no metadata is a special case `runs list` would carry forever.
  *
- * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `runs search`
+ * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `search runs`
  * read instead of every `run.json`. It is only a cache: pruned with its day, and a day without one is read
  * the slow way.
  */
@@ -95,13 +95,21 @@ export declare const startRun: (options: StartRunOptions) => Run;
 export declare const runtime: () => string;
 /** `20260920T084431Z-chats-list-a81f2c` — sortable, and readable without opening it. */
 export declare const newRunId: (startedAt: Date, command: string) => string;
+export interface RunListFilter {
+    runId?: string;
+    command?: string;
+    profile?: string;
+    status?: RunMetadata["status"];
+    errorCode?: string;
+}
 /**
  * Newest first, which is the order anyone asking "what did I just do" wants. Days before `since` are
  * not opened, nor any day once `atLeast` runs are in hand.
  */
-export declare const listRuns: (runsDir: string, { since, atLeast }?: {
+export declare const listRuns: (runsDir: string, { since, atLeast, filter, }?: {
     since?: number;
     atLeast?: number;
+    filter?: RunListFilter;
 }) => RunMetadata[];
 export declare const findRun: (runsDir: string, id: string) => {
     dir: string;

package/dist/runs/run.js

@@ -19,7 +19,7 @@ export const runsDirFor = (app, env = process.env) => join(resolvePaths({ appNam
  * `run.json` is written **now**, with `status: "running"`, and again by `finish`. A directory
  * holding events and no metadata is a special case `runs list` would carry forever.
  *
- * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `runs search`
+ * Each write also appends the metadata to the day's `index.jsonl`, which `runs list` and `search runs`
  * read instead of every `run.json`. It is only a cache: pruned with its day, and a day without one is read
  * the slow way.
  */
@@ -124,17 +124,25 @@ const writeRunFile = (dir, metadata) => {
         // The index only makes reading faster; a day without one is read run by run.
     }
 };
+const matchesListFilter = (run, filter) => (filter.runId === undefined || run.runId === filter.runId) &&
+    (filter.command === undefined || run.command === filter.command) &&
+    (filter.profile === undefined || run.profile === filter.profile) &&
+    (filter.status === undefined || run.status === filter.status) &&
+    (filter.errorCode === undefined || run.errorCode === filter.errorCode);
 /**
  * Newest first, which is the order anyone asking "what did I just do" wants. Days before `since` are
  * not opened, nor any day once `atLeast` runs are in hand.
  */
-export const listRuns = (runsDir, { since, atLeast = Number.POSITIVE_INFINITY } = {}) => {
+export const listRuns = (runsDir, { since, atLeast = Number.POSITIVE_INFINITY, filter = {}, } = {}) => {
     const first = since === undefined ? undefined : day(new Date(since));
     const runs = [];
     for (const date of days(runsDir).sort().reverse()) {
         if ((first !== undefined && date < first) || runs.length >= atLeast)
             break;
-        runs.push(...runsOfDay(join(runsDir, date)));
+        for (const metadata of runsOfDay(join(runsDir, date))) {
+            if (matchesListFilter(metadata, filter))
+                runs.push(metadata);
+        }
     }
     return runs;
 };

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;
     /**
@@ -59,6 +59,13 @@ export interface SendEntry {
     reservation?: string;
     errorCode?: string;
 }
+export interface SendFilter {
+    outcome?: SendOutcome;
+    chatId?: Id;
+    operationId?: string;
+    errorCode?: string;
+    key?: string;
+}
 /**
  * `<state dir>/sends/<profile>.jsonl` — beside `runs`, never in the cache directory, so that
  * clearing a cache cannot erase what was sent in the owner's name.
@@ -88,5 +95,5 @@ export declare class SendJournal {
      * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
      * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
      */
-    entries(): SendEntry[];
+    entries(filter?: SendFilter): SendEntry[];
 }

package/dist/sends/journal.js

@@ -54,13 +54,20 @@ export class SendJournal {
      * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
      * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
      */
-    entries() {
+    entries(filter) {
         const lines = this.#lines();
         const settled = new Set(lines.filter((entry) => entry.outcome !== "reserved").map((entry) => entry.reservation));
-        return lines
+        const entries = lines
             .filter((entry) => entry.outcome !== "reserved" || !settled.has(entry.reservation))
             .map(({ reservation, ...entry }) => (entry.outcome === "reserved" ? { ...entry, reservation } : entry))
             .map(withSendId);
+        return filter === undefined
+            ? entries
+            : entries.filter((entry) => (filter.outcome === undefined || entry.outcome === filter.outcome) &&
+                (filter.chatId === undefined || entry.chatId === filter.chatId) &&
+                (filter.operationId === undefined || entry.operationId === filter.operationId) &&
+                (filter.errorCode === undefined || entry.errorCode === filter.errorCode) &&
+                (filter.key === undefined || entry.key === filter.key));
     }
     #lines() {
         let text;

package/dist/sends/permissions.d.ts

@@ -17,8 +17,12 @@ export type PermissionKey = string;
 export declare const skipFlagFor: (key: string) => "--allow-dangerous" | "--yes";
 /** Only what cannot be undone asks; the tool is meant to work without questions (owner, NEED-460). */
 export declare const DEFAULT_PERMISSIONS: Readonly<Record<PermissionKey, Level>>;
+/** Lets an MCP server offer the commands that change what a later run may do (`grantsAuthority`). */
+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"];
+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

@@ -77,6 +77,35 @@ export const DEFAULT_PERMISSIONS = {
     "chats.clear": "ask",
     // NEED-568: a rule writes to people with nobody typing a command; it waits for the owner's own allow.
     "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. */
+export const authorityAllowed = (levels) => {
+    const { level } = levelFor(levels, AUTHORITY_KEY);
+    return level === "allow" || level === "ask";
 };
 /** The resources at the top of the command tree, which `readOnly` and `allow` turn read-only as a whole. */
 export const RESOURCES = [
@@ -99,6 +128,12 @@ export const RESOURCES = [
     "stats",
     "store",
     "metadata",
+    "mcp",
+    "server",
+    "models",
+    "schedule",
+    "doctor",
+    "images",
 ];
 const OLD_WORDS = {
     send: ["messages.send", "polls.create", "chats.start"],
@@ -365,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). */
@@ -395,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")
@@ -428,7 +466,9 @@ export const keyForCommand = (path) => {
         const inner = keyForCommand(path.slice(1));
         return `bot.${inner ?? path.slice(1).join(".")}`;
     }
-    if (top === undefined || HOUSEKEEPING.has(top))
+    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.
     if (top === "images" && next === "models")

package/dist/sends/recipients.d.ts

@@ -7,6 +7,10 @@ export interface Recipient {
     partnerId?: Id;
     addedAt: string;
 }
+export interface RecipientFilter {
+    id?: Id;
+    title?: string;
+}
 /**
  * A state file, not a setting: the configuration schema has deliberately no place for a chat id,
  * and this list is data about a profile rather than a preference.
@@ -25,6 +29,10 @@ export declare class RecipientList {
     constructor(path: string, command: string, lockWaitMs?: number | undefined);
     /** `undefined` when the list is off. A file that cannot be read refuses rather than opening up. */
     read(): Recipient[] | undefined;
+    list(filter?: RecipientFilter): {
+        state: "off" | "empty" | "on";
+        items: Recipient[];
+    };
     /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
     add(recipient: Recipient): boolean;
     /** `add` waiting for the lock on timers: `recipients add` connects, so it runs inside `serve` when one holds the account. */

package/dist/sends/recipients.js

@@ -36,6 +36,15 @@ export class RecipientList {
                 `fix the file or turn the list off with \`${this.command} recipients clear\``);
         }
     }
+    list(filter = {}) {
+        const chats = this.read();
+        // A query that matches nothing must not describe a nonempty allowlist as allowing nowhere.
+        return {
+            state: chats === undefined ? "off" : chats.length === 0 ? "empty" : "on",
+            items: (chats ?? []).filter((chat) => (filter.id === undefined || chat.id === filter.id) &&
+                (filter.title === undefined || chat.title?.toLocaleLowerCase() === filter.title.toLocaleLowerCase())),
+        };
+    }
     /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
     add(recipient) {
         return this.#locked(() => this.#added(recipient));

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/admin-statistics.js

@@ -216,12 +216,12 @@ export const adminStatisticsService = (deps) => ({
             cutoff,
             olderThan: query.olderThan === undefined && pinned
                 ? pinned.options.olderThan
-                : duration(query.olderThan ?? "24h", "--older-than"),
+                : duration(query.olderThan ?? "24h", "older_than"),
             within: query.within === undefined && pinned ? pinned.options.within : duration(query.within ?? "7d", "--within"),
             joinSince: window.since ?? pinned?.options.joinSince ?? cutoff - 30 * 86_400_000,
             joinUntil: window.until ?? pinned?.options.joinUntil ?? cutoff,
-            minViews: count(query.minViews ?? pinned?.options.minViews ?? 1, "--min-views"),
-            maxReplies: count(query.maxReplies ?? pinned?.options.maxReplies ?? 0, "--max-replies"),
+            minViews: count(query.minViews ?? pinned?.options.minViews ?? 1, "min_views"),
+            maxReplies: count(query.maxReplies ?? pinned?.options.maxReplies ?? 0, "max_replies"),
             answerers: query.answerers === undefined && pinned
                 ? pinned.options.answerers
                 : await answerers(store, query.answerers ?? [], prepared.execution.accounts),

package/dist/services/chat-documents.d.ts

@@ -23,6 +23,7 @@ export interface ChatDocumentsService {
     list(chat: string, window: {
         limit?: number;
         offset: number;
+        ref?: string;
     }): Promise<ChatDocuments>;
 }
 export declare const chatDocumentsService: (deps: ServiceDeps) => ChatDocumentsService;