@wirecat/cli-core 0.563.0 → 0.565.0

package/dist/calendar/writes.js

@@ -165,9 +165,38 @@ export const createEvent = async (context, calendarReference, fields, options =
 };
 /** The longest line `createEventFromText` sends; a quick add is one sentence, not a description. */
 const TEXT_MAX = 1000;
+/** How far the provider's clock may run behind this computer's when a retry looks for what a lost quick add made. */
+const CLOCK_SKEW_MS = 120_000;
+const TIME_DIGITS = 9;
+/**
+ * A quick add's id: `q`, which no hex create id has, then when it was sent, so a retry knows from when to look for the
+ * event it may have made.
+ */
+const quickId = (at) => `q${at.toString(32).padStart(TIME_DIGITS, "0")}${newEventId()}`;
+const QUICK_ID = new RegExp(`^q[a-v0-9]{${TIME_DIGITS}}[a-f0-9]{32}$`, "u");
+const sentAt = (id) => Number.parseInt(id.slice(1, 1 + TIME_DIGITS), 32);
+const wordsOf = (text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+/**
+ * What a lost quick add made: an event this account made on the calendar since the attempt, whose title's every word
+ * is in the line. The provider builds the title from the line's own words.
+ */
+const lostQuickAdd = async (context, calendar, line, id) => {
+    const quickAdded = context.writes.writer.quickAdded;
+    if (!quickAdded)
+        throw new CliError("validation_error", `this provider cannot find a lost quick add; leave out ${context.names.id}`, {
+            param: context.names.id,
+        });
+    const words = new Set(wordsOf(line));
+    const found = (await quickAdded.call(context.writes.writer, calendar, sentAt(id) - CLOCK_SKEW_MS)).filter((entry) => entry.status !== "cancelled" && wordsOf(entry.title ?? "").every((word) => words.has(word)));
+    if (found.length > 1)
+        throw new CliError("validation_error", `${found.length} events made since that attempt could be the one it added; look with events list ` +
+            "changed_at>=today and add it again only if none is", { reason: "event.quick-add-ambiguous", operation_id: id, retryable: false });
+    return found[0];
+};
 /**
  * An event the provider makes from one line of text, as Google's quickAdd. Nobody is mailed unless `notify` says so:
- * the attendees are known only once the provider has read the text.
+ * the attendees are known only once the provider has read the text. The provider picks the event's id, so a retry
+ * with the `id` a lost attempt named first looks for the event that attempt made.
  */
 export const createEventFromText = async (context, calendarReference, text, options = {}) => {
     const quickAdd = context.writes.writer.quickAdd;
@@ -178,29 +207,22 @@ export const createEventFromText = async (context, calendarReference, text, opti
         throw new CliError("validation_error", "the text is empty: say what, when and where");
     if (line.length > TEXT_MAX || /[\r\n]/u.test(line))
         throw new CliError("validation_error", `the text is one line of at most ${TEXT_MAX} characters`);
+    if (options.id !== undefined && !QUICK_ID.test(options.id))
+        throw new CliError("validation_error", `${context.names.id} is the id a quick add's outcome_unknown named`, {
+            param: context.names.id,
+        });
     const calendar = writable(await calendarIn(context.store, context.accountId, calendarReference));
+    const lost = options.id === undefined ? undefined : await lostQuickAdd(context, calendar, line, options.id);
     const notify = options.notify ?? false;
-    const guard = writeGuard(context, keysFor(context, "quick-add", notify));
-    const id = newEventId();
+    const id = lost ? options.id : quickId(context.now);
     let entry;
-    try {
-        entry = await guardedWrite(guard, { chatId: null, kind: "edit", key: COMMAND_KEY["quick-add"], operationId: id, sendId: id, notify }, () => quickAdd.call(context.writes.writer, calendar, line, { notify }));
-    }
-    catch (error) {
-        if (isCliError(error) && error.code === "outcome_unknown")
-            throw new CliError("outcome_unknown", `${error.message} — the provider may have made the event, and a create from text cannot be retried safely: ` +
-                "sync, then look with events list changed_at>=today before adding it again", { ...error.details, operation_id: id, retryable: false });
-        throw error;
-    }
-    let saved;
-    try {
-        ;
-        [saved] = await context.store.saveEntries(calendar.id, [entry], context.now);
-    }
-    catch (error) {
-        throw new CliError(isCliError(error) ? error.code : "invalid_response", `the provider made event ${entry.externalId}, but the local store did not save it ` +
-            `(${error instanceof Error ? error.message : String(error)}); sync to store it — do not create it again`, { ...(isCliError(error) ? error.details : {}), operation_id: id, id: entry.externalId, retryable: false });
+    if (lost)
+        entry = lost;
+    else {
+        const guard = writeGuard(context, keysFor(context, "quick-add", notify));
+        entry = await retryable(context, id, () => guardedWrite(guard, { chatId: null, kind: "edit", key: COMMAND_KEY["quick-add"], operationId: id, sendId: id, notify }, () => quickAdd.call(context.writes.writer, calendar, line, { notify })));
     }
+    const [saved] = await savedAfterCreate(context, id, () => context.store.saveEntries(calendar.id, [entry], context.now));
     return answerOf(id, saved, (entry.recurrence?.length ?? 0) > 0);
 };
 /** The most events one import sends: a file of more is refused before anything goes. */

package/dist/cli/config-command.js

@@ -56,7 +56,7 @@ export const configCommand = (app, config, { permissionKey = config.permissions,
                     ...(declared ? { default: declared.default, description: declared.description } : {}),
                 };
             }),
-            store_settings: await storeSettings(env),
+            store_settings: (await storeSettings(env)).filter(({ setting }) => offersStoreSetting(app, setting)),
         }));
         for (const issue of [
             ...(settings.configIssues ?? []),

package/dist/cli/config-issues.d.ts

@@ -76,11 +76,13 @@ export declare const issueMessage: (issues: readonly ConfigIssue[], doctor?: str
  * `knownPermissions` (from `knownPermissionKeys`), each saved permission key outside it is an issue too, in every
  * section.
  */
-export declare const checkConfigText: <T extends v.GenericSchema>(text: string, { file, tool, schema, knownPermissions, }: {
+export declare const checkConfigText: <T extends v.GenericSchema>(text: string, { file, tool, schema, knownPermissions, repair, }: {
     file: string;
     tool: string;
     schema: T;
     knownPermissions?: ReadonlySet<string>;
+    /** `false` for a CLI with its own `config` that has no `repair`: no fix then names one. */
+    repair?: boolean;
 }) => {
     issues: ConfigIssue[];
     config: v.InferOutput<T> | undefined;

package/dist/cli/config-issues.js

@@ -317,12 +317,12 @@ export const issueMessage = (issues, doctor = "doctor") => {
  * `knownPermissions` (from `knownPermissionKeys`), each saved permission key outside it is an issue too, in every
  * section.
  */
-export const checkConfigText = (text, { file, tool, schema, knownPermissions, }) => {
+export const checkConfigText = (text, { file, tool, schema, knownPermissions, repair = true, }) => {
     const parsed = parseConfigText(text, file);
     if ("issue" in parsed) {
         const issue = publicIssue(parsed.issue);
         // Offered only where it would work, so the desktop never shows a Repair button that fails.
-        if (repairConfigText(text).state === "repaired")
+        if (repair && repairConfigText(text).state === "repaired")
             issue.fix = `${tool} config repair`;
         return { issues: [issue], config: undefined };
     }

package/dist/cli/contract-evidence.d.ts

@@ -15,7 +15,7 @@ export declare const contractEvidence: (root: Command, { fields, errors }?: Cont
     field_only: string[];
     reasons: readonly {
         reason: string;
-        code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "internal_error" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+        code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "conflict" | "internal_error" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
         message: string;
         details: string[];
         step?: string | undefined;

package/dist/cli/early-refusal.d.ts

@@ -22,7 +22,8 @@ export declare const refuseWriteBeforeConnecting: (action: Command, { app, env,
  * A command of a CLI that declares its own keys (`commandPermissions`), refused by its key before anything connects:
  * `deny` stops it, `readonly` stops a write, and the read-only lock stops a write to the service. `ask` is left to
  * the write guard, which can put the question. A saved or `--permission` key that names no command stops every keyed
- * command; housekeeping still runs, so `config unset` can remove it.
+ * command; housekeeping still runs, so `config unset` can remove it. Under the lock a non-messenger CLI still previews
+ * a `--dry-run`, which sends nothing (WC-PERM-12); a messenger's preview stays refused (SEC-65).
  */
 export declare const refuseByCommandPermissions: (action: Command, permissions: CommandPermissions, { app, env, dryRun, resolve }: {
     app: AppIdentity;

package/dist/cli/early-refusal.js

@@ -79,7 +79,8 @@ export const refuseWriteBeforeConnecting = (action, { app, env, dryRun, resolve
  * A command of a CLI that declares its own keys (`commandPermissions`), refused by its key before anything connects:
  * `deny` stops it, `readonly` stops a write, and the read-only lock stops a write to the service. `ask` is left to
  * the write guard, which can put the question. A saved or `--permission` key that names no command stops every keyed
- * command; housekeeping still runs, so `config unset` can remove it.
+ * command; housekeeping still runs, so `config unset` can remove it. Under the lock a non-messenger CLI still previews
+ * a `--dry-run`, which sends nothing (WC-PERM-12); a messenger's preview stays refused (SEC-65).
  */
 export const refuseByCommandPermissions = (action, permissions, { app, env, dryRun, resolve }) => {
     const key = permissions.keyOf(commandPathOf(action));
@@ -87,7 +88,8 @@ export const refuseByCommandPermissions = (action, permissions, { app, env, dryR
         return;
     const { effects } = metaOf(action);
     const lock = readOnlyLockOf(app, env);
-    if (lock && effects?.remote === "write")
+    const preview = dryRun && app.messenger === false;
+    if (lock && effects?.remote === "write" && !preview)
         throw readOnlyRefusal(lock, `run ${commandPathOf(action).join(" ")}`);
     const flags = action.optsWithGlobals();
     const overrides = environmentOf(action).agent?.overrides ?? [];

package/dist/cli/entry.d.ts

@@ -16,8 +16,12 @@ export interface EntryContext {
     atStart: (command: Command) => Promise<void>;
     /** A yes/no question on stderr; false without asking when there is no terminal, under CI, `--json`, `--jsonl` or `--no-input`. */
     ask: (question: string, command?: Command) => Promise<boolean>;
-    /** Opens the URL in the system browser, or in `browser` when given; never waits for the browser to close. */
-    openBrowser: (url: string, browser?: string) => Promise<void>;
+    /**
+     * Opens the URL in the system browser, or in `browser` when given; never waits for the browser to close. Does nothing
+     * where nobody can use a browser (WC-CMD-15): under CI, `--json`, `--jsonl`, `--no-input`, or with no terminal.
+     * The caller prints the URL either way.
+     */
+    openBrowser: (url: string, browser?: string, command?: Command) => Promise<void>;
     /** True once a reader closed the output (`| head`): nothing more reaches the terminal. */
     outputClosed: () => boolean;
 }

package/dist/cli/entry.js

@@ -88,7 +88,10 @@ export const startCli = async (entry) => {
             });
             return /^(y|yes)$/i.test(answer.trim());
         },
-        openBrowser: (url, browser) => openBrowser(url, browser, io),
+        openBrowser: async (url, browser, command) => {
+            if (!headless(command))
+                await openBrowser(url, browser, io);
+        },
         outputClosed: () => closed,
     };
     let code;

package/dist/cli/envelope.d.ts

@@ -89,7 +89,7 @@ export declare const answerSchema: (item?: v.GenericSchema) => v.UnionSchema<[v.
         readonly accounts: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>, undefined>;
         readonly complete: v.BooleanSchema<undefined>;
         readonly issues: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
-            readonly code: v.PicklistSchema<readonly ["validation_error", "configuration_error", "authentication_error", "permission_error", "not_found", "confirmation_required", "rate_limited", "timeout", "network_error", "provider_error", "provider_unavailable", "invalid_response", "outcome_unknown", "cancelled"], undefined>;
+            readonly code: v.PicklistSchema<readonly ["validation_error", "configuration_error", "authentication_error", "permission_error", "not_found", "confirmation_required", "rate_limited", "timeout", "network_error", "provider_error", "provider_unavailable", "invalid_response", "outcome_unknown", "conflict", "cancelled"], undefined>;
             readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>, undefined>;
             readonly source: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
         }, undefined>, undefined>, undefined>;
@@ -144,7 +144,7 @@ export declare const answerSchema: (item?: v.GenericSchema) => v.UnionSchema<[v.
         readonly accounts: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>, undefined>, undefined>;
         readonly complete: v.BooleanSchema<undefined>;
         readonly issues: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
-            readonly code: v.PicklistSchema<readonly ["validation_error", "configuration_error", "authentication_error", "permission_error", "not_found", "confirmation_required", "rate_limited", "timeout", "network_error", "provider_error", "provider_unavailable", "invalid_response", "outcome_unknown", "cancelled"], undefined>;
+            readonly code: v.PicklistSchema<readonly ["validation_error", "configuration_error", "authentication_error", "permission_error", "not_found", "confirmation_required", "rate_limited", "timeout", "network_error", "provider_error", "provider_unavailable", "invalid_response", "outcome_unknown", "conflict", "cancelled"], undefined>;
             readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "dotted lower-case words, such as `page.next`">]>, undefined>;
             readonly source: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "must not be empty">]>;
         }, undefined>, undefined>, undefined>;

package/dist/cli/index.d.ts

@@ -45,6 +45,7 @@ export { type AgentPolicy, type AgentTask, type EvaluationResult, evaluateAgent,
 export { answerEntity } from "./answer-entity.js";
 export { type AppDoctorOptions, appDoctorReport } from "./app-doctor-command.js";
 export type { AppMcpOptions } from "./app-mcp-command.js";
+export { actorOf } from "./author.js";
 export type { ApiCommandInput, ApiCommands } from "./bot/api.js";
 export { apiFlagOf, apiJson, apiOptionKey, apiPlainJson, checkApiBody, checkApiParameter, parseApiJson, readApiBody, } from "./bot/api-input.js";
 export { prepareRpcApiBody, type RpcApiBody } from "./bot/api-rpc.js";

package/dist/cli/index.js

@@ -39,6 +39,7 @@ export { liftOptionsAfterDashes } from "./after-dashes.js";
 export { evaluateAgent, } from "./agent-evaluation.js";
 export { answerEntity } from "./answer-entity.js";
 export { appDoctorReport } from "./app-doctor-command.js";
+export { actorOf } from "./author.js";
 export { apiFlagOf, apiJson, apiOptionKey, apiPlainJson, checkApiBody, checkApiParameter, parseApiJson, readApiBody, } from "./bot/api-input.js";
 export { prepareRpcApiBody } from "./bot/api-rpc.js";
 export { botContext, botWords } from "./bot/context.js";

package/dist/cli/messenger/archive-commands.js

@@ -26,6 +26,7 @@ export const storeCommand = (messenger) => {
     const store = new Command("store")
         .description("the local store of messages")
         .addCommand(statusCommand(messenger))
+        .addCommand(storedChatsCommand(messenger))
         .addCommand(gapsCommand(messenger))
         .addCommand(jobsCommand(messenger))
         .addCommand(exportCommand(messenger))
@@ -35,6 +36,7 @@ export const storeCommand = (messenger) => {
     const examples = {
         backup: "./backup.db",
         check: "",
+        "chats status": "",
         clear: "--left --dry-run",
         "copies delete": "messages_copy_1",
         decrypt: "./backup.enc --output ./restored.db",
@@ -93,6 +95,21 @@ const statusCommand = (messenger) => annotate(new Command("status"), { output: {
                 .map((skip) => `  ${skip.title ?? skip.chatId}  ${skip.messages} messages  ${skip.reason}`)
                 .join("\n"));
 });
+/** `store status` summed over the account's chats, for a count of what the archive holds without a list of them. */
+const storedChatsCommand = (messenger) => {
+    const chats = new Command("chats").description("the account's chats as the store holds them");
+    annotate(chats.command("status"), { output: { entity: "chat_coverage" }, effects: LOCAL_READ })
+        .summary("how many chats the archive holds in full, in part, or not at all")
+        .description("over this account's searchable chats of every kind, channels included: fetched (back to the first message, " +
+        "up to date, no gaps), partial, never (no fetch recorded and no message held), and the oldest message held; " +
+        "reads the store only")
+        .action(async function () {
+        const context = messengerContext(this, messenger);
+        const coverage = await context.withStore((store, account) => store.chats.chatCoverage(account));
+        renderAnswer(this, context, itemOf(snakeKeys(coverage)));
+    });
+    return chats;
+};
 const LISTED = 20;
 /** Titles are the owner's: these lines go to a person's terminal, never into an error message. */
 const leftLines = (left) => {

package/dist/cli/messenger/catch-up-answers.d.ts

@@ -18,6 +18,8 @@ type Read = Message & {
     chatTitle?: string | null;
 };
 /** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+/** Written by others, and by the owner, so an agent quotes it and never follows it (WC-SECR-21). */
+export declare const SUMMARY_UNTRUSTED: string[];
 export declare const summaryOf: (message: Read, reader: AccountKey) => {
     ref: string;
     chat_id: string;
@@ -61,6 +63,7 @@ export declare const summaryOf: (message: Read, reader: AccountKey) => {
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 };
 export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, reader: AccountKey, transcribe: boolean, meta?: Partial<Meta>) => import("../envelope.js").ListBody<{
     ref: string;
@@ -105,6 +108,7 @@ export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, r
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 }>;
 /** What `review --offline` cannot see. */
 export declare const OFFLINE_REVIEW = "offline: only what was already synced to the local store; run review without --offline for the rest";
@@ -160,5 +164,6 @@ export declare const reviewAnswer: (found: Review, hearing: Hearing | undefined,
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 }>;
 export {};

package/dist/cli/messenger/catch-up-answers.js

@@ -34,6 +34,8 @@ export const catchUpQuery = (words, registry, command) => {
     };
 };
 /** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+/** Written by others, and by the owner, so an agent quotes it and never follows it (WC-SECR-21). */
+export const SUMMARY_UNTRUSTED = ["chat_title", "sender_name", "text", "transcript", "attachments.name"];
 export const summaryOf = (message, reader) => {
     const { ref, chat_id, chat_title, timestamp, sender_name, sender_is_me, outgoing, text, transcript, attachments } = messageItem(message, reader);
     return {
@@ -47,6 +49,7 @@ export const summaryOf = (message, reader) => {
         text,
         ...(transcript === undefined ? {} : { transcript }),
         attachments,
+        untrusted: SUMMARY_UNTRUSTED,
     };
 };
 const nameOf = (chat) => chat.title ?? chat.id;

package/dist/cli/messenger/search-answers.d.ts

@@ -18,6 +18,7 @@ export type NoteHitItem = InferOutput<(typeof ENTITIES)["note.hit"]>;
 export type HitItem = InferOutput<(typeof ENTITIES)["hit"]>;
 /** The page a `--page` asks for, as the offset the search services take. */
 export declare const offsetOf: (page: number | undefined, limit: number) => number | undefined;
+export declare const MAIL_HIT_UNTRUSTED: string[];
 export declare const messageHitItem: (hit: FoundMessage, query?: string) => MessageHitItem;
 /**
  * What the store holds of a chat that is not complete, in words. A chat that reaches its first message is only

package/dist/cli/messenger/search-answers.js

@@ -26,7 +26,7 @@ const MESSAGE_HIT_UNTRUSTED = [
     "follow_ups.excerpt",
     "attachments.name",
 ];
-const MAIL_HIT_UNTRUSTED = [
+export const MAIL_HIT_UNTRUSTED = [
     "email.subject",
     "email.from.name",
     "email.to.name",

package/dist/cli/messenger/stats-answers.d.ts

@@ -10,8 +10,8 @@ import type { MessageStats } from "../../services/messages-search.js";
 import type { RankingFound } from "../../services/rankings.js";
 import type { ReplyTimes, Waiting } from "../../services/reply-stats.js";
 import type { RetentionService } from "../../services/retention.js";
+import type { TaskStats } from "../../services/task-stats.js";
 import type { AccountKey, RankedEvidence } from "../../store/store.js";
-import type { GroupStats } from "../../tasks/index.js";
 import { type ItemBody, type ListBody } from "../envelope.js";
 type Of<T extends keyof typeof ENTITIES> = InferOutput<(typeof ENTITIES)[T]>;
 type RetentionFound = Awaited<ReturnType<RetentionService["report"]>>;
@@ -71,8 +71,8 @@ export declare const refuseJsonl: (format: string) => void;
 export declare const chatStatsAnswer: (stats: ChatStats, account: AccountKey, meta?: Partial<Meta>) => ItemBody<Of<"chat_stats">>;
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */
 export declare const MEMBERS_UNRECORDED = "joins and leaves are not recorded for this chat yet, so they are not counted";
-/** `stats tasks show`, CLI and MCP alike. */
-export declare const taskStatsAnswer: (rows: GroupStats[], account: AccountKey) => ItemBody<Of<"task_stats">>;
+/** `stats tasks show`, CLI and MCP alike. A row of `--by chat` also names its chat as `chat`, as it always has. */
+export declare const taskStatsAnswer: (stats: TaskStats, account: AccountKey) => ItemBody<Of<"task_stats">>;
 export declare const responsesAnswer: (found: ReplyTimes) => ItemBody<Of<"response_times">>;
 export declare const waitingAnswer: (found: Waiting) => ItemBody<Of<"waiting_chats">>;
 export {};

package/dist/cli/messenger/stats-answers.js

@@ -410,15 +410,27 @@ export const chatStatsAnswer = (stats, account, meta) => {
 };
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */
 export const MEMBERS_UNRECORDED = "joins and leaves are not recorded for this chat yet, so they are not counted";
-/** `stats tasks show`, CLI and MCP alike. */
-export const taskStatsAnswer = (rows, account) => itemOf({
-    open: rows.reduce((sum, row) => sum + row.open, 0),
-    rows: rows.map((row) => ({
-        chat: chatRef(account, row.group),
-        open: row.open,
-        oldest_open_at: row.oldestOpenAt?.toISOString() ?? null,
-        median_close_ms: row.medianCloseMs ?? null,
-    })),
+/** `stats tasks show`, CLI and MCP alike. A row of `--by chat` also names its chat as `chat`, as it always has. */
+export const taskStatsAnswer = (stats, account) => itemOf({
+    open: stats.open,
+    created: stats.created,
+    closed: stats.closed,
+    median_close_ms: stats.medianCloseMs ?? null,
+    mean_open_age_ms: stats.meanOpenAgeMs ?? null,
+    rows: stats.rows.map((row) => {
+        const chat = stats.by === "chat" ? chatRef(account, row.group) : undefined;
+        return {
+            ...(chat === undefined ? {} : { chat }),
+            key: chat ?? (stats.by === "project" ? `project:${row.group}` : row.group),
+            name: row.name,
+            open: row.open,
+            created: row.created,
+            closed: row.closed,
+            oldest_open_at: row.oldestOpenAt?.toISOString() ?? null,
+            median_close_ms: row.medianCloseMs ?? null,
+            mean_open_age_ms: row.meanOpenAgeMs ?? null,
+        };
+    }),
 });
 const replyFigures = (one) => ({
     replies: one.replies,

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/messenger/tasks-command.js

@@ -8,7 +8,8 @@ import { aheadOf, momentOf } from "../../services/moment.js";
 import { refuseAlreadyRead } from "../../services/task-analysis.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
-import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
+import { TASK_STATS_BY } from "../../services/task-stats.js";
+import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, TASK_STATS_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
 import { PRIORITY_LABELS, priorityOption } from "../../tasks/index.js";
 import { actorOf, holderOf as holderIn } from "../author.js";
 import { environmentOf } from "../context.js";
@@ -539,32 +540,52 @@ export const tasksCommand = (messenger) => {
     });
     return tasks;
 };
+const statsByOf = (value) => {
+    if (!TASK_STATS_BY.includes(value))
+        throw new CliError("validation_error", `--by takes ${TASK_STATS_BY.join(", ")}`);
+    return value;
+};
+const minutes = (ms) => (ms === undefined ? "" : `${Math.round(ms / 60_000)} min`);
 export const tasksStatsCommand = (messenger) => {
-    return annotate(new Command("show"), { effects: LOCAL_READ, output: { entity: "task_stats" } })
-        .description("per chat: how many tasks are open, the oldest open one, the median time to close")
+    return withQuery(annotate(new Command("show"), {
+        effects: LOCAL_READ,
+        output: { entity: "task_stats" },
+        examples: [`${messenger.app.command} stats tasks show --by meeting -- created>=30d`],
+    }), TASK_STATS_QUERY)
+        .summary("count tasks by chat, meeting or project, open and closed")
+        .description("tasks per chat, meeting or project: open now, and opened and closed in the period (created: in the query), " +
+        "with the median time to close and the mean age of the open ones")
+        .option("--by <group>", "chat (default) or meeting: this account's tasks; project: the owner's project tasks, every project", statsByOf)
         .option("--chat <chat>", `only this chat; ${messenger.chatArgument}`)
         .option("--type <type>", "only this type: question, request, mention or promise", taskTypeOf)
-        .action(async function () {
+        .option("--timezone <zone>", "the IANA timezone for calendar days in the period, such as created>=today")
+        .action(async function (words) {
         const context = messengerContext(this, messenger);
-        const { chat, type } = this.opts();
+        const { by, chat, type, timezone } = this.opts();
         refuseJsonl(context.format);
-        const { rows, account } = await context.withServices(async (services) => ({
-            rows: await services.tasks.stats({
+        const query = listQuery(typedQuery(words), TASK_STATS_QUERY, "stats tasks show");
+        const { stats, account } = await context.withServices(async (services) => ({
+            stats: await services.tasks.stats({
+                ...(by === undefined ? {} : { by }),
                 ...(chat === undefined ? {} : { chat }),
-                ...(type === undefined ? {} : { type }),
+                ...(type === undefined ? {} : { kind: type }),
+                ...(query === undefined ? {} : { query }),
+                ...(timezone === undefined ? {} : { timezone }),
             }),
             account: await services.messages.reader(),
         }));
-        if (rows.length === 0)
+        if (stats.rows.length === 0)
             context.renderer.note("no tasks yet");
-        renderAnswer(this, context, taskStatsAnswer(rows, account), () => rows.length === 0
+        renderAnswer(this, context, taskStatsAnswer(stats, account), () => stats.rows.length === 0
             ? ""
-            : `${rows
-                .map(({ group, open, oldestOpenAt, medianCloseMs }) => [
-                group,
+            : `${stats.rows
+                .map(({ group, name, open, created, closed, oldestOpenAt, medianCloseMs }) => [
+                name ? `${name} (${group})` : group,
                 `${open} open`,
+                `${created} created`,
+                `${closed} closed`,
                 oldestOpenAt ? `oldest ${oldestOpenAt.toISOString().slice(0, 16).replace("T", " ")}` : "",
-                medianCloseMs === undefined ? "" : `median ${Math.round(medianCloseMs / 60_000)} min to close`,
+                medianCloseMs === undefined ? "" : `median ${minutes(medianCloseMs)} to close`,
             ]
                 .filter(Boolean)
                 .join("  "))

package/dist/cli/permission-keys.d.ts

@@ -14,12 +14,14 @@ export interface CommandPermissions {
     extra: readonly PermissionKey[];
     /** cli-core's built-in levels and the CLI's own; they only ever tighten. */
     defaults: Readonly<Record<PermissionKey, Level>>;
+    /** The other keys a command's real run checks, so its `--dry-run` preview shows each: gcal's `api.calendar.*`. */
+    alsoChecks?: (path: readonly string[]) => readonly PermissionKey[];
 }
 /** Either way of naming a program's keys: a messenger's per-command mapping, or a declared CLI's own. */
 export type PermissionKeySource = PermissionKeyOf | CommandPermissions;
 /** A command's own path is its key; the commands that look after the tool have none. */
 export declare const commandPathKey: (path: readonly string[]) => PermissionKey | null;
-export declare const commandPermissions: ({ keyOf, extra, defaults, }?: Partial<CommandPermissions>) => CommandPermissions;
+export declare const commandPermissions: ({ keyOf, extra, defaults, alsoChecks, }?: Partial<CommandPermissions>) => CommandPermissions;
 /**
  * The keys `permissions` may name: every command of the program, every write key, and each of their
  * parents. A key outside it is a typo that would otherwise do nothing (BUG-137).

package/dist/cli/permission-keys.js

@@ -16,10 +16,11 @@ const HOUSEKEEPING = new Set([
 ]);
 /** A command's own path is its key; the commands that look after the tool have none. */
 export const commandPathKey = (path) => path[0] === undefined || HOUSEKEEPING.has(path[0]) ? null : path.join(".");
-export const commandPermissions = ({ keyOf = commandPathKey, extra = [], defaults = {}, } = {}) => ({
+export const commandPermissions = ({ keyOf = commandPathKey, extra = [], defaults = {}, alsoChecks, } = {}) => ({
     keyOf,
     extra: [AUTHORITY_KEY, ...extra],
     defaults: { ...DEFAULT_PERMISSIONS, ...defaults },
+    ...(alsoChecks ? { alsoChecks } : {}),
 });
 const pathOf = (command) => {
     const words = [];

package/dist/cli/preview.d.ts

@@ -10,6 +10,10 @@ export declare const preview: (command: Command, settings: Pick<Settings, "permi
     permission?: {
         key: PermissionKey | null;
         level: string;
+        also?: {
+            key: PermissionKey;
+            level: string;
+        }[];
     } | undefined;
     validation: {
         arguments: string;
@@ -42,12 +46,20 @@ export declare const preview: (command: Command, settings: Pick<Settings, "permi
 export declare const previewBody: (command: Command, permission: {
     key: PermissionKey | null;
     level: string;
+    also?: {
+        key: PermissionKey;
+        level: string;
+    }[];
 } | undefined, messenger: boolean) => {
     preview: boolean;
     path: string[];
     permission?: {
         key: PermissionKey | null;
         level: string;
+        also?: {
+            key: PermissionKey;
+            level: string;
+        }[];
     } | undefined;
     validation: {
         arguments: string;

package/dist/cli/preview.js

@@ -23,7 +23,14 @@ export const preview = (command, settings, tool, keys, messenger = true) => {
         (!declared && key !== null && key !== undefined && WRITE_KEYS.includes(key));
     if (level === "deny" || (writes && level === "readonly"))
         throw new CliError("permission_error", `this profile does not permit ${path.join(" ")}`, { permission: key });
-    return previewBody(command, { key: key ?? null, level }, messenger);
+    const also = (declared?.alsoChecks?.(path) ?? []).map((one) => ({
+        key: one,
+        level: levelFor(permissions, one, declared?.defaults).level,
+    }));
+    const stopped = also.find((one) => one.level === "deny" || (writes && one.level === "readonly"));
+    if (stopped)
+        throw new CliError("permission_error", `this profile does not permit ${stopped.key}`, { permission: stopped.key });
+    return previewBody(command, { key: key ?? null, level, ...(also.length ? { also } : {}) }, messenger);
 };
 const TARGETS = new Set(["chat", "message", "person", "profile"]);
 /**

package/dist/cli/settings.d.ts

@@ -42,6 +42,8 @@ export interface SettingsExtension<T extends object = Record<never, never>> {
      * `--permission` then take any command path, which the program checks against its commands.
      */
     permissions?: CommandPermissions;
+    /** `false` for a CLI with its own `config` that has no `repair`: no config issue then names one. */
+    configRepair?: boolean;
 }
 export interface SettingsExtensionContext {
     flags: GlobalFlags;

package/dist/cli/settings.js

@@ -102,6 +102,8 @@ export const MESSENGER_ONLY_SETTINGS = [
     "history_group_days",
     "history_group_members_max",
     "read_other_bots",
+    "speech_model",
+    "picture_search",
 ];
 /** One program, one version: whether to look for a newer one is not a per-profile matter. */
 const SHARED_DEFAULTS_ONLY = {
@@ -259,7 +261,12 @@ export const settingsFor = (app, extension = {}) => {
             return { config: { profiles: {} }, issues: [read.issue] };
         if (read.text === undefined)
             return { config: { profiles: {} }, issues: [] };
-        const { config, issues } = checkConfigText(read.text, { file: path, tool: app.command, schema: readSchema });
+        const { config, issues } = checkConfigText(read.text, {
+            file: path,
+            tool: app.command,
+            schema: readSchema,
+            repair: extension.configRepair !== false,
+        });
         return { config: (config ?? { profiles: {} }), issues };
     };
     /**

package/dist/conversations/mail-text.d.ts

@@ -4,3 +4,9 @@
  * not hold stays, so a forward or a reply to an unsaved email is still found.
  */
 export declare const mailCore: (body: string, earlier: string[]) => string;
+/**
+ * What an email says itself, for a model that should not read earlier mail or the sender's signature: no quoted
+ * lines, nothing after a reply or Outlook header, no signature or mobile footer. A forwarded message is kept whole,
+ * since it is what was sent. When nothing would be left — an email that is only a quote — the body stays as it is.
+ */
+export declare const mailOwnText: (body: string) => string;