@wirecat/cli-core 0.591.0 → 0.592.0

package/CHANGELOG.md

@@ -7,6 +7,8 @@ shape of this file.
 
 ## Unreleased
 
+## 0.592.0 — 06.11.2026
+
 ## 0.591.0 — 06.11.2026
 
 ### Added
@@ -28,6 +30,17 @@ shape of this file.
   in `@wirecat/cli-core`.
 - **`DealFilter.account` and `offset`, `pipelines({ account })`.** A list reads the owner's own (`"own"`) or one CRM
   account's copies, a page at a time.
+- **`schedule agent` and `schedule command` take `--to <route>`, repeatable.** After the run, when `--notify-on`
+  says so, the scheduler sends the result through the owner's own CLI: `telegram-bot:<profile>/<chat id or
+  user:id>` runs `tg <profile> bot messages send`, `email:<profile>/<address>` runs `mail <profile> messages send`.
+  A finished run sends its output (an agent's report, a command's log): to a bot as one message up to 4096
+  characters, else as a file with its first lines as the caption; by mail as the body, the title as the subject. A
+  failed run sends one line: exit code, reason id, the log's path. The run itself stays read-only; nothing it prints
+  can change where the result goes; a run under `<PREFIX>_READ_ONLY` sends nothing. Each route's outcome is in
+  `last.json` as `deliveries` (`to`, `ok`, a dotted `reason`, the sending CLI's error code); a failed send never fails
+  the run, and `schedule list` shows it. `ServerSystem.run` takes an optional `{ input, timeoutMs }`.
+- **`store.mail.writtenTo(addresses)`.** Of these addresses, the ones the owner wrote to: To or Cc of a live outgoing
+  email in any account, in lower case, in one read.
 
 - **`syncCrm` and the `CrmSource` port, in `@wirecat/cli-core/crm`.** A CRM CLI writes an adapter (`pipelines(kind)`,
   `changes(kind, cursor, page)` answering a page or `{ reset: true }`, and `ids(kind, page)` when the CRM does not name

package/dist/background/deliver.d.ts

@@ -0,0 +1,58 @@
+import { type ServerSystem } from "./system.js";
+/**
+ * Where a schedule's result goes after the run, by the owner's own CLI: a Telegram bot's message (`tg <profile> bot
+ * messages send`) or an email (`mail <profile> messages send`). Only the schedule file names it, so nothing the run
+ * printed can move it; the run itself never sends.
+ */
+export type Route = {
+    kind: "telegram-bot";
+    profile: string;
+    chat: string;
+} | {
+    kind: "email";
+    profile: string;
+    address: string;
+};
+export declare const ROUTE_HELP = "telegram-bot:<profile>/<chat id or user:id>, or email:<profile>/<address>";
+export declare const parseRoute: (text: string) => Route;
+export declare const routeText: (route: Route) => string;
+export declare const DELIVERY_REASONS: {
+    readonly readOnly: "delivery.read-only";
+    readonly programMissing: "delivery.program-missing";
+    readonly routeInvalid: "delivery.route-invalid";
+    readonly timeout: "delivery.timeout";
+    readonly failed: "delivery.failed";
+};
+export type DeliveryReason = (typeof DELIVERY_REASONS)[keyof typeof DELIVERY_REASONS];
+/** One route's outcome, kept in `last.json`. `error` is the sending CLI's error code and reason id, never its message. */
+export interface Delivery {
+    to: string;
+    ok: boolean;
+    reason?: DeliveryReason;
+    error?: string;
+}
+/** Telegram's limits, in UTF-16 units as JavaScript counts them: a message's text, and a file's caption. */
+export declare const TELEGRAM_TEXT_CHARS = 4096;
+export declare const CAPTION_CHARS = 1024;
+/** The caption: the title, then the report's first lines as far as they fit, cut where a line ends. */
+export declare const headOf: (title: string, report: string, limit?: number) => string;
+export interface Parcel {
+    title: string;
+    /** A finished run: its output file, and the name the copy sent along has. */
+    file?: {
+        path: string;
+        name: string;
+    };
+    /** A failed run: one line, no file. */
+    line?: string;
+}
+/** Hands the parcel to each route's CLI, one after another; a route that fails is recorded and the next one still goes. */
+export declare const deliver: (system: ServerSystem, env: NodeJS.ProcessEnv, routes: readonly string[], parcel: Parcel, { find, errorOf, locked, timeoutMs, }: {
+    /** Where a program is on the run's PATH. */
+    find: (name: string, env: NodeJS.ProcessEnv) => string | undefined;
+    /** The one line kept of a failed send's stderr. */
+    errorOf: (stderr: string, code: number) => string;
+    /** The lock the scheduler itself runs under: nothing goes out from a locked run. */
+    locked?: string;
+    timeoutMs?: number;
+}) => Promise<Delivery[]>;

package/dist/background/deliver.js

@@ -0,0 +1,125 @@
+import { copyFileSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { TIMED_OUT } from "./system.js";
+const PROGRAMS = {
+    "telegram-bot": { command: "tg", prefix: "TG" },
+    email: { command: "mail", prefix: "MAIL" },
+};
+// A chat by its id only: a title can change, or name a second chat, and the report would go there.
+const CHAT = /^(-?\d+|user:\d+)$/;
+// The profile-name rule of src/cli/profile.ts, which this layer may not import.
+const PROFILE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const ADDRESS = /^[^\s@/,<>"]+@[^\s@/,<>"]+\.[^\s@/,<>"]+$/;
+export const ROUTE_HELP = "telegram-bot:<profile>/<chat id or user:id>, or email:<profile>/<address>";
+export const parseRoute = (text) => {
+    const [, kind = "", profile = "", target = ""] = /^([a-z-]+):([^/]+)\/(.+)$/.exec(text.trim()) ?? [];
+    const refuse = (why) => new CliError("validation_error", `--to ${text}: ${why} — ${ROUTE_HELP}`);
+    if (!(kind in PROGRAMS))
+        throw refuse(kind ? `${kind} is not a route` : "a route is <kind>:<profile>/<where>");
+    if (!PROFILE.test(profile))
+        throw refuse(`"${profile}" is not a profile name`);
+    if (kind === "telegram-bot") {
+        if (!CHAT.test(target))
+            throw refuse("a bot writes to a chat id or user:<id>, never a title");
+        return { kind, profile, chat: target };
+    }
+    if (!ADDRESS.test(target))
+        throw refuse(`"${target}" is not one email address`);
+    return { kind: "email", profile, address: target };
+};
+export const routeText = (route) => `${route.kind}:${route.profile}/${route.kind === "telegram-bot" ? route.chat : route.address}`;
+export const DELIVERY_REASONS = {
+    readOnly: "delivery.read-only",
+    programMissing: "delivery.program-missing",
+    routeInvalid: "delivery.route-invalid",
+    timeout: "delivery.timeout",
+    failed: "delivery.failed",
+};
+/** Telegram's limits, in UTF-16 units as JavaScript counts them: a message's text, and a file's caption. */
+export const TELEGRAM_TEXT_CHARS = 4096;
+export const CAPTION_CHARS = 1024;
+const DELIVERY_TIMEOUT_MS = 120_000;
+/** The caption: the title, then the report's first lines as far as they fit, cut where a line ends. */
+export const headOf = (title, report, limit = CAPTION_CHARS) => {
+    const more = "\n… the whole report is in the file";
+    const room = limit - title.length - 1;
+    const text = report.trim();
+    if (text.length <= room)
+        return text ? `${title}\n${text}` : title;
+    const cut = text.slice(0, room - more.length);
+    const line = cut.lastIndexOf("\n");
+    return `${title}\n${line > room / 2 ? cut.slice(0, line) : cut}${more}`;
+};
+/**
+ * The words that send along `route`. A bot sends a report that fits one message as its text, and a longer one as a
+ * file with its head as the caption; mail takes the text on stdin. The text goes after `--`, so a report that starts
+ * with a dash stays text.
+ */
+const argvOf = (program, route, title, report, copy) => {
+    const lead = [program, route.profile, "--json", "--no-input"];
+    if (route.kind === "email")
+        return [...lead, "messages", "send", "--to", route.address, "--subject", title];
+    const text = copy ? headOf(title, report) : report.trim() ? `${title}\n${report.trim()}` : title;
+    return [...lead, "bot", "messages", "send", ...(copy ? ["--file", copy] : []), "--", route.chat, text];
+};
+/** Hands the parcel to each route's CLI, one after another; a route that fails is recorded and the next one still goes. */
+export const deliver = async (system, env, routes, parcel, { find, errorOf, locked, timeoutMs = DELIVERY_TIMEOUT_MS, }) => {
+    const failed = (to, reason, error) => ({
+        to,
+        ok: false,
+        reason,
+        ...(error ? { error } : {}),
+    });
+    const report = parcel.line ?? (parcel.file ? readFileSync(parcel.file.path, "utf8") : "");
+    const out = [];
+    for (const to of routes) {
+        let route;
+        try {
+            route = parseRoute(to);
+        }
+        catch {
+            out.push(failed(to, DELIVERY_REASONS.routeInvalid));
+            continue;
+        }
+        const { command, prefix } = PROGRAMS[route.kind];
+        const lock = locked ?? [`${prefix}_READ_ONLY`].find((name) => env[name] && env[name] !== "0");
+        if (lock) {
+            out.push(failed(to, DELIVERY_REASONS.readOnly, lock));
+            continue;
+        }
+        const program = find(command, env);
+        if (!program) {
+            out.push(failed(to, DELIVERY_REASONS.programMissing, command));
+            continue;
+        }
+        const tooLong = `${parcel.title}\n${report.trim()}`.length > TELEGRAM_TEXT_CHARS;
+        // The sending CLI refuses its own and the other WireCat folders, where the report lives, so it gets a copy.
+        const folder = route.kind === "telegram-bot" && parcel.file && tooLong ? mkdtempSync(join(tmpdir(), "wirecat-deliver-")) : "";
+        const copy = folder && parcel.file ? join(folder, parcel.file.name) : undefined;
+        try {
+            if (copy && parcel.file)
+                copyFileSync(parcel.file.path, copy);
+            const { [`${prefix}_PROFILE`]: _, ...childEnv } = env;
+            const ran = await system.run(argvOf(program, route, parcel.title, report, copy), childEnv, {
+                timeoutMs,
+                ...(route.kind === "email" ? { input: report.trim() ? report : parcel.title } : {}),
+            });
+            if (ran.code === 0)
+                out.push({ to, ok: true });
+            else if (ran.code === TIMED_OUT)
+                out.push(failed(to, DELIVERY_REASONS.timeout));
+            else
+                out.push(failed(to, DELIVERY_REASONS.failed, errorOf(ran.stderr, ran.code)));
+        }
+        catch {
+            out.push(failed(to, DELIVERY_REASONS.failed));
+        }
+        finally {
+            if (folder)
+                rmSync(folder, { recursive: true, force: true });
+        }
+    }
+    return out;
+};

package/dist/background/schedules.d.ts

@@ -1,4 +1,5 @@
 import { type AppIdentity } from "../ports/app.js";
+import { type Delivery } from "./deliver.js";
 import type { ServerSystem } from "./system.js";
 /** Minutes between runs, a daily local time, or one local moment. */
 export type When = {
@@ -24,8 +25,10 @@ export interface Schedule {
     mailBatch?: number;
     /** An agent's: no run starts for the rest of the local day once its runs cost this much, in US dollars. */
     maxCostPerDay?: number;
-    /** When a finished run shows a desktop notice; absent means `notifyOf`'s default. */
+    /** When a finished run shows a desktop notice and goes along `to`; absent means `notifyOf`'s default. */
     notify?: Notify;
+    /** Delivery routes (`telegram-bot:<profile>/<chat>`, `email:<profile>/<address>`) the result goes along after the run. */
+    to?: string[];
 }
 export declare const NOTIFY_WHEN: readonly ["always", "failures", "never"];
 export type Notify = (typeof NOTIFY_WHEN)[number];
@@ -71,6 +74,8 @@ export interface LastRun {
         why: string;
         reason?: SkipReason;
     };
+    /** How the result went along each of the schedule's routes; a failed delivery never fails the run. */
+    deliveries?: Delivery[];
 }
 /** Why a timer left a run out, as an id a translation can key on; `why` stays the English sentence. */
 export declare const SKIP_REASONS: {

package/dist/background/schedules.js

@@ -5,6 +5,7 @@ import { CliError, errorCodes, writeSecurely } from "@wirecat/cli-base";
 import { mailHolderVariable, readOnlyLockOf } from "../ports/app.js";
 import { recordLogFor } from "../runs/record-log.js";
 import { childTrace } from "../runs/scope.js";
+import { deliver } from "./deliver.js";
 export const NOTIFY_WHEN = ["always", "failures", "never"];
 /** A repeating agent would otherwise notify on every tick; any other schedule runs rarely enough to say each result. */
 export const notifyOf = (schedule) => schedule.notify ?? (schedule.kind === "agent" && "every" in schedule.when ? "failures" : "always");
@@ -105,6 +106,11 @@ export const recordRun = (path, run) => {
     writeSecurely(path, `${JSON.stringify(last, null, 2)}\n`, 0o600);
     return last;
 };
+const recordDeliveries = (path, last, deliveries) => {
+    const delivered = { ...last, deliveries };
+    writeSecurely(path, `${JSON.stringify(delivered, null, 2)}\n`, 0o600);
+    return delivered;
+};
 /** Notes on the last run that the timer left this one out, keeping that run's result. */
 export const recordSkip = (file, why, reason, at = new Date()) => {
     const path = join(file, "..", "last.json");
@@ -455,6 +461,32 @@ export const runSchedule = async (app, system, env, file, { now = () => new Date
     else if (exitCode !== 0 && mode !== "never") {
         await notify(system, env, title, `failed (exit ${exitCode}) — ${errors}`);
     }
+    const routes = schedule.to ?? [];
+    if (routes.length > 0 && (exitCode === 0 ? mode === "always" : mode !== "never")) {
+        const at = shortTime(last.at);
+        const runEnv = { ...env, ...schedule.environment };
+        const locked = readOnlyLockOf(app, runEnv);
+        const deliveries = await deliver(system, runEnv, routes, exitCode === 0
+            ? {
+                title: `${title} · ${at}`,
+                file: { path: output, name: `${schedule.name}-${at.replace(/[ :]/g, "-")}.${agent ? "md" : "txt"}` },
+            }
+            : {
+                title: `${title} failed · ${at}`,
+                line: `${title} failed at ${at} (exit ${exitCode}` +
+                    `${last.failures && last.failures > 1 ? `, ${last.failures} runs in a row` : ""})` +
+                    `${last.reason ? `: ${last.reason}` : ""} — ${errors}`,
+            }, {
+            find: (name, on) => findProgram(name, on, system.platform),
+            errorOf: reasonOf,
+            ...(locked ? { locked } : {}),
+        });
+        last = recordDeliveries(join(folder, "last.json"), last, deliveries);
+        const lost = deliveries.filter((one) => !one.ok);
+        if (lost.length > 0 && mode !== "never") {
+            await notify(system, env, title, lost.map((one) => `not delivered to ${one.to}: ${one.reason}`).join("\n"));
+        }
+    }
     if ("once" in schedule.when) {
         await timer?.remove(schedule.name);
         rmSync(file, { force: true });

package/dist/background/system.d.ts

@@ -4,9 +4,16 @@ export interface Ran {
     stderr: string;
 }
 /** What `server` asks of the machine. Tests hand one in; nothing else does. */
+/** What a run may hand the program besides its words: text on its stdin, and a time after which it is stopped. */
+export interface RunOptions {
+    input?: string;
+    timeoutMs?: number;
+}
+/** The exit code a program stopped at `RunOptions.timeoutMs` answers, as `timeout(1)` does. */
+export declare const TIMED_OUT = 124;
 export interface ServerSystem {
     platform: NodeJS.Platform;
-    run: (argv: string[], env: NodeJS.ProcessEnv) => Promise<Ran>;
+    run: (argv: string[], env: NodeJS.ProcessEnv, options?: RunOptions) => Promise<Ran>;
     /** The command line that starts this CLI: the node binary and the script, both absolute. */
     entry: string[];
     uid: number;
@@ -15,5 +22,5 @@ export interface ServerSystem {
     /** The pause between two looks at whether `serve` is listening yet. */
     pause: () => Promise<void>;
 }
-export declare const runProgram: (argv: string[], env: NodeJS.ProcessEnv) => Promise<Ran>;
+export declare const runProgram: (argv: string[], env: NodeJS.ProcessEnv, { input, timeoutMs }?: RunOptions) => Promise<Ran>;
 export declare const thisMachine: () => ServerSystem;

package/dist/background/system.js

@@ -3,15 +3,22 @@ import { closeSync, mkdirSync, openSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { CliError } from "@wirecat/cli-base";
-export const runProgram = (argv, env) => new Promise((resolve, reject) => {
+/** The exit code a program stopped at `RunOptions.timeoutMs` answers, as `timeout(1)` does. */
+export const TIMED_OUT = 124;
+export const runProgram = (argv, env, { input, timeoutMs } = {}) => new Promise((resolve, reject) => {
     const [file = "", ...args] = argv;
-    execFile(file, args, { env, encoding: "utf8" }, (error, stdout, stderr) => {
+    const child = execFile(file, args, { env, encoding: "utf8", ...(timeoutMs ? { timeout: timeoutMs } : {}) }, (error, stdout, stderr) => {
         if (error?.code === "ENOENT") {
             reject(new CliError("configuration_error", `${file} was not found — this machine has no ${file} to run serve`));
             return;
         }
-        resolve({ code: typeof error?.code === "number" ? error.code : error ? 1 : 0, stdout, stderr });
+        const code = error?.killed ? TIMED_OUT : typeof error?.code === "number" ? error.code : error ? 1 : 0;
+        resolve({ code, stdout, stderr });
     });
+    // A program that does not read its stdin may close it first; that is no failure of the run.
+    child.stdin?.on("error", () => { });
+    if (input !== undefined)
+        child.stdin?.end(input);
 });
 export const thisMachine = () => {
     // The path as the package manager's shim gave it, not resolved: pnpm's global link keeps its name across upgrades

package/dist/calendar/mcp/index.d.ts

@@ -10,13 +10,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -45,9 +45,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -58,9 +58,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -80,13 +80,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -115,9 +115,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -128,9 +128,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -150,13 +150,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -185,9 +185,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -198,9 +198,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -220,13 +220,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -255,9 +255,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -268,9 +268,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;

package/dist/cli/schedule/schedule-command.js

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { CliError, resolvePaths, writeSecurely } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Argument, Command, Option } from "commander";
+import { parseRoute, ROUTE_HELP, routeText } from "../../background/deliver.js";
 import { describeWhen, findProgram, lastRun, listSchedules, NOTIFY_WHEN, notifyOf, readSchedule, recordSkip, runSchedule, SCHEDULE_DEFAULTS, SKIP_REASONS, scheduleFile, scheduleName, spentToday, timerFor, } from "../../background/schedules.js";
 import { thisMachine } from "../../background/system.js";
 import { locationVariables } from "../../background/units.js";
@@ -80,7 +81,13 @@ const withWhen = (command) => command
     .option("--every <duration>", "repeat: 30m, 2h, 1d")
     .option("--at <HH:MM>", "every day at this local time")
     .option("--at-time <time>", "one run: 30m, 2d from now, or an ISO time; the schedule removes itself after it")
-    .addOption(new Option("--notify-on <when>", "desktop notice after a run (default failures for an agent that repeats with --every, else always)").choices(NOTIFY_WHEN));
+    .addOption(new Option("--notify-on <when>", "desktop notice after a run (default failures for an agent that repeats with --every, else always)").choices(NOTIFY_WHEN))
+    .option("--to <route>", `also send the result, when --notify-on says so, by the owner's own tg or mail: ${ROUTE_HELP}; repeat it for more`, (route, routes = []) => [...routes, routeText(parseRoute(route))]);
+/** What a schedule keeps of `--notify-on` and `--to`. */
+const deliveryOf = ({ notifyOn, to }) => ({
+    ...(notifyOn ? { notify: notifyOn } : {}),
+    ...(to?.length ? { to } : {}),
+});
 /** What the schedule command needs of a CLI: who it is and, per command, where it prints and which profile runs. */
 /** `skill show follow-ups` exists only for messenger CLIs; any other CLI gets a read-only summary it can run. */
 const promptExample = (app) => app.messenger === false
@@ -254,7 +261,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             when: whenOf(this.opts(), COMMAND_MINIMUM_MINUTES),
             environment: environment(),
             createdAt: new Date().toISOString(),
-            ...(this.opts().notifyOn ? { notify: this.opts().notifyOn } : {}),
+            ...deliveryOf(this.opts()),
         });
     });
     withWhen(grantsAuthority(annotate(command.command("agent"), {
@@ -336,7 +343,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             ...(mailWaitMinutes === undefined ? {} : { mailWaitMinutes }),
             ...(mailBatch === undefined ? {} : { mailBatch }),
             ...(options.maxCostPerDay === undefined ? {} : { maxCostPerDay: options.maxCostPerDay }),
-            ...(options.notifyOn ? { notify: options.notifyOn } : {}),
+            ...deliveryOf(options),
         });
     });
     if (newMail)
@@ -358,6 +365,7 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
             kind: schedule.kind,
             when: describeWhen(schedule.when),
             notify: notifyOf(schedule),
+            ...(schedule.to?.length ? { to: schedule.to } : {}),
             last: lastRun(scheduleFile(state, schedule.name)) ?? null,
             ...(schedule.kind === "agent"
                 ? {
@@ -378,11 +386,12 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
                 return "";
             }
             return rows
-                .map(({ name, kind, when, notify, last, spentTodayUsd, maxCostPerDayUsd }) => [
+                .map(({ name, kind, when, notify, to, last, spentTodayUsd, maxCostPerDayUsd }) => [
                 name,
                 kind,
                 when,
                 `notify ${notify}`,
+                ...(to ? [`to ${to.join(", ")}`] : []),
                 last
                     ? `last ${last.at.slice(0, 16).replace("T", " ")} exit ${last.exitCode}` +
                         (last.failures
@@ -396,6 +405,9 @@ export const scheduleCommandFor = ({ app, context: contextOf, newMail, limits: c
                 ...(last?.skipped
                     ? [`skipped ${last.skipped.at.slice(0, 16).replace("T", " ")}: ${last.skipped.why}`]
                     : []),
+                ...(last?.deliveries ?? [])
+                    .filter((one) => !one.ok)
+                    .map((one) => `not delivered to ${one.to}: ${one.reason}${one.error ? ` (${one.error})` : ""}`),
             ].join("  "))
                 .join("\n");
         });

package/dist/entities/index.d.ts

@@ -4112,6 +4112,7 @@ export declare const ENTITIES: {
         readonly kind: v.PicklistSchema<["command", "agent"], undefined>;
         readonly when: v.StringSchema<undefined>;
         readonly notify: v.OptionalSchema<v.PicklistSchema<["always", "failures", "never"], undefined>, undefined>;
+        readonly to: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly last: v.NullableSchema<v.StrictObjectSchema<{
             readonly 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 exit_code: v.NumberSchema<undefined>;
@@ -4127,6 +4128,12 @@ export declare const ENTITIES: {
                 readonly why: v.StringSchema<undefined>;
                 readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
             }, undefined>, undefined>;
+            readonly deliveries: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly to: v.StringSchema<undefined>;
+                readonly ok: v.BooleanSchema<undefined>;
+                readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
+                readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, undefined>;
         }, undefined>, undefined>;
         readonly spent_today_usd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
         readonly max_cost_usd: v.OptionalSchema<v.NullableSchema<v.NumberSchema<undefined>, undefined>, undefined>;

package/dist/entities/list-results.d.ts

@@ -50,6 +50,8 @@ export declare const scheduledJob: v.StrictObjectSchema<{
     readonly when: v.StringSchema<undefined>;
     /** When a finished run shows a desktop notice: `always`, `failures` or `never`; the default is shown, not left out. */
     readonly notify: v.OptionalSchema<v.PicklistSchema<["always", "failures", "never"], undefined>, undefined>;
+    /** Where a run's result is sent after it: `telegram-bot:<profile>/<chat>` or `email:<profile>/<address>`. */
+    readonly to: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly last: v.NullableSchema<v.StrictObjectSchema<{
         readonly 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 exit_code: v.NumberSchema<undefined>;
@@ -67,6 +69,13 @@ export declare const scheduledJob: v.StrictObjectSchema<{
             /** A dotted id for `why`, so a client can translate it: `cost.day-cap`, `mail.none-new`, `mail.below-threshold`. */
             readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
         }, undefined>, undefined>;
+        /** How the run's result went along each route; `reason` a dotted id, `error` the sending CLI's code and reason id. */
+        readonly deliveries: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly to: v.StringSchema<undefined>;
+            readonly ok: v.BooleanSchema<undefined>;
+            readonly reason: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
+            readonly error: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
     }, undefined>, undefined>;
     /** Agent schedules: what today's runs cost, in US dollars. */
     readonly spent_today_usd: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;

package/dist/entities/list-results.js

@@ -34,6 +34,8 @@ export const scheduledJob = v.strictObject({
     when: text,
     /** When a finished run shows a desktop notice: `always`, `failures` or `never`; the default is shown, not left out. */
     notify: v.optional(v.picklist(["always", "failures", "never"])),
+    /** Where a run's result is sent after it: `telegram-bot:<profile>/<chat>` or `email:<profile>/<address>`. */
+    to: v.optional(v.array(text)),
     last: v.nullable(v.strictObject({
         at: time,
         exit_code: v.number(),
@@ -51,6 +53,13 @@ export const scheduledJob = v.strictObject({
             /** A dotted id for `why`, so a client can translate it: `cost.day-cap`, `mail.none-new`, `mail.below-threshold`. */
             reason: v.optional(v.pipe(text, v.regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/))),
         })),
+        /** How the run's result went along each route; `reason` a dotted id, `error` the sending CLI's code and reason id. */
+        deliveries: v.optional(v.array(v.strictObject({
+            to: text,
+            ok: v.boolean(),
+            reason: v.optional(v.pipe(text, v.regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/))),
+            error: v.optional(text),
+        }))),
     })),
     /** Agent schedules: what today's runs cost, in US dollars. */
     spent_today_usd: v.optional(v.number()),

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

@@ -79,6 +79,8 @@ export interface MailActivityStore {
     }[]>;
     /** Each live email's marks, by its Message-ID; one the store does not hold is left out. */
     emailMarks(accountId: number, externalIds: readonly string[]): Promise<Map<string, EmailMarks>>;
+    /** Of these addresses, the ones the owner has written to, in lower case: To or Cc of a live outgoing email, any account. */
+    writtenTo(addresses: readonly string[]): Promise<Set<string>>;
     /**
      * Each live thread of the account whose newest email is after `since` (ms), newest first, with the facts of that
      * email. `where` is a `tasks agenda` query compiled over `MAIL_AGENDA_COLUMNS`.
@@ -99,5 +101,6 @@ export declare const threadEmailIds: (database: CacheDatabase, accountId: number
     until?: number;
 }) => number[];
 export declare const emailMarks: (database: CacheDatabase, accountId: number, externalIds: readonly string[]) => Map<string, EmailMarks>;
+export declare const writtenTo: (database: CacheDatabase, addresses: readonly string[]) => Set<string>;
 export declare const emailsAfter: (database: CacheDatabase, accountId: number, afterId: number, limit: number, ids?: readonly number[]) => MarkedEmail[];
 export declare const mailActivity: (database: CacheDatabase) => MailActivityStore;

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

@@ -88,6 +88,16 @@ export const emailMarks = (database, accountId, externalIds) => {
     }
     return marks;
 };
+export const writtenTo = (database, addresses) => {
+    if (addresses.length === 0)
+        return new Set();
+    const rows = database
+        .prepare(`SELECT DISTINCT lower(r.address) AS address FROM emails e JOIN email_recipients r ON r.email_id = e.id
+       WHERE e.outgoing = 1 AND e.deleted_at IS NULL AND r.role IN ('to', 'cc')
+         AND lower(r.address) IN (SELECT value FROM json_each(?))`)
+        .all(JSON.stringify(addresses.map((address) => address.toLowerCase())));
+    return new Set(rows.map((row) => String(row.address)));
+};
 const MARKED = `
   SELECT e.id, e.external_id, t.external_id AS thread, coalesce(e.received_at, e.sent_at) AS at, e.created_at,
     e.updated_at, coalesce(e.draft, 0) AS draft, json_extract(e.metadata, '$.partial') IS NOT NULL AS partial,
@@ -135,5 +145,6 @@ export const mailActivity = (database) => ({
         .all(accountId, prefix.length, prefix)
         .map((row) => ({ key: String(row.key), value: String(row.value), at: Number(row.updated_at) })),
     emailMarks: async (accountId, externalIds) => emailMarks(database, accountId, externalIds),
+    writtenTo: async (addresses) => writtenTo(database, addresses),
     threadActivity: async (accountId, since, where) => threadActivity(database, accountId, since, where),
 });

package/package.json

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

package/parity.json

@@ -1065,7 +1065,7 @@
     },
     "--to": {
       "value": "<chat>",
-      "meaning": "the chat to forward it to: an id, or part of a chat name",
+      "meaning": "where it goes: the chat to forward it to (an id, or part of a chat name), or a route a schedule's result is sent along (telegram-bot:<profile>/<chat>, email:<profile>/<address>)",
       "note": "the sentence says how to name a chat the messenger's way, so it differs on purpose (Help text rule 4)"
     },
     "--topic": {
@@ -3988,6 +3988,12 @@
           "planned": {
             "wa": "wa backlog: mount the shared schedule command"
           }
+        },
+        "--to": {
+          "in": ["max", "tg"],
+          "planned": {
+            "wa": "wa backlog: mount the shared schedule command"
+          }
         }
       }
     },
@@ -4020,6 +4026,12 @@
           "planned": {
             "wa": "wa backlog: mount the shared schedule command"
           }
+        },
+        "--to": {
+          "in": ["max", "tg"],
+          "planned": {
+            "wa": "wa backlog: mount the shared schedule command"
+          }
         }
       }
     },