@wirecat/cli-core 0.530.0 → 0.532.0

package/dist/cli/schedule/schedule-command.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { type AppIdentity } from "../../ports/app.js";
+import { type AnswerOutput } from "../envelope.js";
+/** What the schedule command needs of a CLI: who it is and, per command, where it prints and which profile runs. */
+export interface ScheduleHost {
+    app: AppIdentity;
+    context(command: Command, resolving?: {
+        needsProfile?: boolean;
+    }): AnswerOutput & {
+        env: NodeJS.ProcessEnv;
+        profile: string;
+    };
+}
+/**
+ * Runs the CLI's own commands, or an agent, later or on a timer — through systemd (Linux), launchd
+ * (macOS) or Task Scheduler (Windows). Every timer runs `schedule exec <file>`; the schedule file holds
+ * the rest, so what runs and with which variables is the same on all three.
+ */
+export declare const scheduleCommandFor: ({ app, context: contextOf }: ScheduleHost) => Command;

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

@@ -0,0 +1,261 @@
+import { existsSync, rmSync } from "node:fs";
+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 { describeWhen, findProgram, lastRun, listSchedules, readSchedule, runSchedule, scheduleFile, scheduleName, timerFor, } from "../../background/schedules.js";
+import { thisMachine } from "../../background/system.js";
+import { locationVariables } from "../../background/units.js";
+import { parseDuration } from "../../domain/duration.js";
+import { readOnlyLockOf } from "../../ports/app.js";
+import { aheadOf } from "../../services/moment.js";
+import { storePath } from "../../store/path.js";
+import { environmentOf, setExitCode } from "../context.js";
+import { grantsAuthority, LOCAL_READ, LOCAL_WRITE, REMOTE_WRITE } from "../effects.js";
+import { itemOf, listOf, renderAnswer, snakeKeys } from "../envelope.js";
+import { withQuery } from "../list-query.js";
+import { SCHEDULES_QUERY, scheduleFilter } from "../messenger/list-result-queries.js";
+import { lineOf } from "../steps.js";
+/** Each run of an agent is a paid model call that reads chats; keeping the store current is `serve`'s job. */
+const AGENT_MINIMUM_MINUTES = 60;
+const COMMAND_MINIMUM_MINUTES = 1;
+const HARNESSES = ["claude", "codex"];
+const whenOf = ({ every, at, atTime }, minimum) => {
+    if ([every ?? at, atTime].filter(Boolean).length !== 1) {
+        throw new CliError("validation_error", "say when: --every <30m|2h|1d>, --at HH:MM (daily), or --at-time <30m|2d|ISO time>");
+    }
+    if (atTime) {
+        const time = aheadOf(atTime, "--at-time");
+        if (time <= Date.now())
+            throw new CliError("validation_error", "--at-time is in the past");
+        return { once: new Date(time).toISOString() };
+    }
+    if (at) {
+        if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(at))
+            throw new CliError("validation_error", `--at takes HH:MM, not "${at}"`);
+        if (every && parseDuration(every, "--every") !== 86_400_000) {
+            throw new CliError("validation_error", "--at runs once a day; leave out --every, or use --every 1d");
+        }
+        return { daily: at };
+    }
+    const minutes = parseDuration(every ?? "", "--every") / 60_000;
+    if (!Number.isInteger(minutes) || minutes < minimum) {
+        throw new CliError("validation_error", `--every is at least ${minimum} minute${minimum === 1 ? "" : "s"} here, in whole minutes`);
+    }
+    return { every: minutes };
+};
+/** A schedule as answered: snake_case, but its environment keeps the variables' own names. */
+const scheduleAnswer = ({ environment, createdAt, ...schedule }, extra) => ({
+    ...snakeKeys(schedule),
+    environment,
+    created_at: createdAt,
+    ...snakeKeys(extra),
+});
+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");
+/**
+ * Runs the CLI's own commands, or an agent, later or on a timer — through systemd (Linux), launchd
+ * (macOS) or Task Scheduler (Windows). Every timer runs `schedule exec <file>`; the schedule file holds
+ * the rest, so what runs and with which variables is the same on all three.
+ */
+export const scheduleCommandFor = ({ app, context: contextOf }) => {
+    const command = new Command("schedule").description(`run a ${app.command} command or an agent later or on a timer (systemd, launchd, Task Scheduler); an agent cannot send`);
+    const prepare = (self, resolving = {}) => {
+        const context = contextOf(self, resolving);
+        const system = environmentOf(self).system ?? thisMachine();
+        const state = resolvePaths({ appName: app.appName, prefix: app.envPrefix, env: context.env }).state;
+        const say = (value, lines) => renderAnswer(self, context, itemOf(value), () => lines.join("\n"));
+        const timer = () => timerFor(app, system, context.env);
+        // The command line refuses a schedule under the lock; a caller that gets here still passes the lock on.
+        const readOnly = readOnlyLockOf(app, context.env);
+        const environment = () => ({
+            [`${app.envPrefix}_PROFILE`]: context.profile,
+            ...locationVariables(app, context.env),
+            // The timer starts with almost no PATH; an agent runs `max` and its own tools by name.
+            ...(context.env.PATH ? { PATH: context.env.PATH } : {}),
+            ...(readOnly ? { [readOnly]: "1" } : {}),
+        });
+        const save = async (schedule) => {
+            const file = scheduleFile(state, schedule.name);
+            const replaced = existsSync(file);
+            if (replaced) {
+                const owner = readSchedule(file).environment[`${app.envPrefix}_PROFILE`];
+                if (owner && owner !== context.profile) {
+                    throw new CliError("validation_error", `schedule ${schedule.name} already runs for profile ${owner}; name this one for ${context.profile}, e.g. ${schedule.name}-${context.profile}`);
+                }
+            }
+            writeSecurely(file, `${JSON.stringify(schedule, null, 2)}\n`, 0o600);
+            await timer().install(schedule, [...system.entry, "schedule", "exec", file]);
+            say(scheduleAnswer(schedule, { file, timer: timer().where(schedule.name), replaced }), [
+                `${replaced ? "Replaced" : "Added"} ${schedule.name}: ${describeWhen(schedule.when)}.`,
+                `It runs: ${schedule.kind === "agent" ? schedule.argv.join(" ") : `${app.command} ${schedule.argv.join(" ")}`}`,
+                `Output: ${join(dirname(file), "runs")} · now: ${lineOf(self, `schedule run ${schedule.name}`)} · stop: ${lineOf(self, `schedule remove ${schedule.name}`)}`,
+            ]);
+        };
+        return { context, system, state, say, timer, environment, save };
+    };
+    withWhen(grantsAuthority(annotate(command.command("command"), {
+        effects: LOCAL_WRITE,
+        examples: [
+            `${app.command} personal schedule command health --every 1h -- doctor`,
+            `${app.command} personal schedule command morning-check --at 08:00 -- doctor`,
+        ],
+    }))
+        .description(`run ${app.command} <args…> on a timer — reads save what they read, so this is how a chat's history fills the store`)
+        .argument("<name>", "lowercase letters, digits and dashes")
+        .argument("<args...>", `the ${app.command} command after its name, e.g. -- messages list <chat> --limit 50`)).action(async function (name, args) {
+        const { environment, save } = prepare(this);
+        if (args[0] === "schedule")
+            throw new CliError("validation_error", "a schedule cannot run schedule");
+        await save({
+            name: scheduleName(name),
+            kind: "command",
+            argv: args,
+            when: whenOf(this.opts(), COMMAND_MINIMUM_MINUTES),
+            environment: environment(),
+            createdAt: new Date().toISOString(),
+        });
+    });
+    withWhen(grantsAuthority(annotate(command.command("agent"), {
+        effects: LOCAL_WRITE,
+        examples: [
+            `${app.command} personal schedule agent review claude "review what came in overnight and draft replies" --at 08:30`,
+            `${app.command} personal schedule agent triage codex "list what needs an answer today" --every 2h --max-cost 1`,
+        ],
+    }))
+        .description(`start an agent (claude or codex) with a prompt on a timer; it runs with ${app.envPrefix}_READ_ONLY=1, so it reads and drafts and cannot send — its answer is kept and you are notified`)
+        .argument("<name>", "lowercase letters, digits and dashes")
+        .addArgument(new Argument("<harness>", "the agent to start").choices(HARNESSES))
+        .argument("<prompt>", `what to do, e.g. "run the daily follow-up review: ${app.command} skill show follow-ups"`)
+        .addOption(new Option("--max-cost <usd>", "claude only: stop a run that costs more than this, in US dollars").argParser(Number))).action(async function (name, harness, prompt) {
+        const { context, system, environment, save } = prepare(this);
+        const options = this.opts();
+        const program = findProgram(harness, context.env, system.platform);
+        if (!program)
+            throw new CliError("not_found", `${harness} is not on PATH`);
+        const paths = resolvePaths({ appName: app.appName, prefix: app.envPrefix, env: context.env });
+        const argv = harness === "claude"
+            ? [
+                program,
+                "-p",
+                prompt,
+                // The owner's own settings may let every tool run (bypassPermissions); here only the CLI may.
+                "--permission-mode",
+                "dontAsk",
+                "--allowedTools",
+                `Bash(${app.command}:*)`,
+                "--no-session-persistence",
+                ...(options.maxCost ? ["--max-budget-usd", String(options.maxCost)] : []),
+            ]
+            : [
+                program,
+                "exec",
+                "--skip-git-repo-check",
+                "--ephemeral",
+                "--sandbox",
+                "workspace-write",
+                // The CLI reaches the messenger and writes its store and state, and nothing else.
+                "-c",
+                "sandbox_workspace_write.network_access=true",
+                ...[dirname(storePath(context.env)), paths.state, paths.config, paths.cache].flatMap((dir) => [
+                    "--add-dir",
+                    dir,
+                ]),
+                prompt,
+            ];
+        await save({
+            name: scheduleName(name),
+            kind: "agent",
+            argv,
+            when: whenOf(options, AGENT_MINIMUM_MINUTES),
+            environment: environment(),
+            createdAt: new Date().toISOString(),
+        });
+    });
+    withQuery(annotate(command.command("list"), {
+        effects: LOCAL_READ,
+        examples: [`${app.command} personal schedule list`, `${app.command} personal schedule list kind:agent`],
+    }), SCHEDULES_QUERY)
+        .description("the schedules, when they run and how their last run went")
+        .action(function (words) {
+        const filter = scheduleFilter(words);
+        const { context, state } = prepare(this);
+        const rows = listSchedules(state, filter).map((schedule) => ({
+            name: schedule.name,
+            kind: schedule.kind,
+            when: describeWhen(schedule.when),
+            last: lastRun(scheduleFile(state, schedule.name)) ?? null,
+        }));
+        const answer = listOf("schedule list", {
+            items: rows.map((row) => snakeKeys(row)),
+            limit: Math.max(1, rows.length),
+            has_more: false,
+        });
+        renderAnswer(this, context, answer, () => {
+            if (rows.length === 0) {
+                context.renderer.note(`no schedules — \`${lineOf(this, "schedule command|agent")}\` adds one`);
+                return "";
+            }
+            return rows
+                .map(({ name, kind, when, last }) => [
+                name,
+                kind,
+                when,
+                last
+                    ? `last ${last.at.slice(0, 16).replace("T", " ")} exit ${last.exitCode}` +
+                        (last.failures
+                            ? ` — failing since ${(last.failingSince ?? last.at).slice(0, 16).replace("T", " ")}, ` +
+                                `${last.failures} in a row${last.reason ? `: ${last.reason}` : ""} — ${last.output}`
+                            : "")
+                    : "not run yet",
+            ].join("  "))
+                .join("\n");
+        });
+    });
+    annotate(command.command("run"), {
+        effects: REMOTE_WRITE,
+        examples: [`${app.command} personal schedule run health`],
+    })
+        .description("run a schedule now, as its timer would, and wait for it")
+        .argument("<name>", "the schedule's name, as `schedule list` shows it")
+        .action(async function (name) {
+        const { context, system, state, say, timer } = prepare(this);
+        const last = await runSchedule(app, system, context.env, scheduleFile(state, scheduleName(name)), {
+            timer: timer(),
+        });
+        say(snakeKeys({ name, ...last }), [`${name}: exit ${last.exitCode} — ${last.output}`]);
+        if (last.exitCode !== 0)
+            setExitCode(this, 1);
+    });
+    grantsAuthority(annotate(command.command("remove"), {
+        effects: LOCAL_WRITE,
+        examples: [`${app.command} personal schedule remove health`],
+    }))
+        .description("stop a schedule and remove its timer; its past output stays")
+        .argument("<name>", "the schedule's name, as `schedule list` shows it")
+        .action(async function (name) {
+        const { state, say, timer } = prepare(this);
+        const file = scheduleFile(state, scheduleName(name));
+        if (!existsSync(file))
+            throw new CliError("not_found", `no schedule ${name} — \`${lineOf(this, "schedule list")}\``);
+        await timer().remove(name);
+        rmSync(file, { force: true });
+        say({ name, removed: true }, [`Removed ${name}.`]);
+    });
+    annotate(command.command("exec"), {
+        effects: REMOTE_WRITE,
+        examples: [`${app.command} schedule exec ~/.local/share/${app.appName}/schedules/health/schedule.json`],
+    })
+        .description("what a timer runs, given the schedule's file; to run one by hand, use run")
+        .argument("<file>", "the schedule's schedule.json in the state folder, as the timer passes it")
+        .action(async function (file) {
+        // A timer starts it with no profile named; the schedule's own environment carries the profile.
+        const { context, system, timer } = prepare(this, { needsProfile: false });
+        const last = await runSchedule(app, system, context.env, file, { timer: timer() });
+        if (last.exitCode !== 0)
+            setExitCode(this, 1);
+    });
+    return command;
+};

package/dist/cli/shared-command-exports.d.ts

@@ -765,7 +765,7 @@ export declare const stickersCommand: (messenger: import("./index.js").Messenger
 export declare const repliesCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const reviewCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const scheduleCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
-export declare const scheduleCommandFor: (args_0: import("./messenger/schedule-command.js").ScheduleHost) => import("commander").Command;
+export declare const scheduleCommandFor: (args_0: import("./schedule/schedule-command.js").ScheduleHost) => import("commander").Command;
 export declare const searchCommand: (messenger: import("./index.js").Messenger, args_1?: {
     topics?: boolean;
 } | undefined) => import("commander").Command;

package/dist/cli/shared-command-exports.js

@@ -41,7 +41,7 @@ import { reactionsCommand as reactionsCommandDefinition } from "./messenger/reac
 import { callsCommand as callsCommandDefinition, stickersCommand as stickersCommandDefinition, } from "./messenger/records-command.js";
 import { repliesCommand as repliesCommandDefinition } from "./messenger/replies-command.js";
 import { reviewCommand as reviewCommandDefinition } from "./messenger/review.js";
-import { scheduleCommand as scheduleCommandDefinition, scheduleCommandFor as scheduleCommandForDefinition, } from "./messenger/schedule-command.js";
+import { scheduleCommand as scheduleCommandDefinition } from "./messenger/schedule-command.js";
 import { searchCommand as searchCommandDefinition } from "./messenger/search-command.js";
 import { searchesCommand as searchesCommandDefinition } from "./messenger/searches-command.js";
 import { serveCommand as serveCommandDefinition } from "./messenger/serve-command.js";
@@ -52,6 +52,7 @@ import { tasksCommand as tasksCommandDefinition, tasksStatsCommand as tasksStats
 import { topicsCommand as topicsCommandDefinition } from "./messenger/topics-command.js";
 import { watchCommand as watchCommandDefinition } from "./messenger/watch-command.js";
 import { runsCommand as runsCommandDefinition } from "./runs/command.js";
+import { scheduleCommandFor as scheduleCommandForDefinition } from "./schedule/schedule-command.js";
 import { sharedCommand as protectedCommand } from "./shared-contracts.js";
 import { skillCommand as skillCommandDefinition } from "./skill-command.js";
 import { upgradeCommand as upgradeCommandDefinition } from "./upgrade-command.js";

package/dist/domain/attachments.d.ts

@@ -1,6 +1,14 @@
-import type { ProviderMetadata } from "./models.js";
+import type { Attachment, ProviderMetadata } from "./models.js";
 /** Attachments that are never a file, so their messages cost no download request. */
 export declare const NOT_FILES: ReadonlySet<string>;
+/** A file a message carries, as a search hit names it; `position` counts every attachment, from 1. */
+export interface HitFile {
+    position: number;
+    kind: string;
+    name?: string;
+    size?: number;
+}
+export declare const hitFiles: (attachments: readonly Attachment[] | undefined) => HitFile[];
 /** The stored kinds `has:<kind>` matches: MAX stores a file as `file`, Telegram as `document`. */
 export declare const storedKinds: (kind: string) => string[];
 /** One file `messages download` saved, as the messenger described it. */

package/dist/domain/attachments.js

@@ -9,6 +9,18 @@ export const NOT_FILES = new Set([
     "call",
     "inline_keyboard",
 ]);
+// The position is taken before the filter: the store numbers every attachment, and `--attachment` takes that number.
+// A server search hit built by an adapter may come without attachments at all.
+export const hitFiles = (attachments) => (attachments ?? []).flatMap(({ kind, name, size }, index) => NOT_FILES.has(kind)
+    ? []
+    : [
+        {
+            position: index + 1,
+            kind,
+            ...(name === undefined ? {} : { name }),
+            ...(size === undefined ? {} : { size }),
+        },
+    ]);
 /** The stored kinds `has:<kind>` matches: MAX stores a file as `file`, Telegram as `document`. */
 export const storedKinds = (kind) => (kind === "file" ? ["file", "document"] : [kind]);
 /**

package/dist/domain/message-link.d.ts

@@ -1,3 +1,4 @@
+import type { Attachment } from "./models.js";
 export type MessagePermalink = {
     url: string;
     access: "public" | "restricted" | "unknown";
@@ -7,9 +8,22 @@ export type MessagePermalink = {
     access: "unavailable";
     reason: "unsupported_chat" | "unsupported_provider" | "offline";
 };
+/**
+ * A link to one file of the message, apart from the message's own. No messenger gives one yet: Telegram and
+ * WhatsApp have none, and MAX's are short-lived download addresses that hand the bytes to whoever holds them.
+ */
+export interface FileLink {
+    position: number;
+    kind: string;
+    name?: string;
+    url: null;
+    reason: "unsupported_provider";
+}
 export type MessageLink = MessagePermalink & {
     locator: string;
+    files?: FileLink[];
 };
+export declare const fileLinks: (attachments: readonly Attachment[]) => FileLink[];
 export declare const messageLinkTarget: (reference: string, message: string | undefined, provider: string) => {
     chat: string;
     message: string;

package/dist/domain/message-link.js

@@ -1,5 +1,13 @@
 import { CliError } from "@wirecat/cli-base";
+import { hitFiles } from "./attachments.js";
 import { isLocator, parseLocator } from "./locator.js";
+export const fileLinks = (attachments) => hitFiles(attachments).map(({ position, kind, name }) => ({
+    position,
+    kind,
+    ...(name === undefined ? {} : { name }),
+    url: null,
+    reason: "unsupported_provider",
+}));
 export const messageLinkTarget = (reference, message, provider) => {
     if (isLocator(reference)) {
         if (message !== undefined)

package/dist/domain/models.d.ts

@@ -608,6 +608,8 @@ export interface TopicChange {
     pinned?: boolean;
     /** Only a forum's General topic can be hidden from the topic list. */
     hidden?: boolean;
+    /** An emoji from the messenger's topic icon set; `null` removes the icon. */
+    icon?: string | null;
 }
 /** Someone who asked to join a group or channel that needs an admin's approval. */
 export interface JoinRequest {

package/dist/entities/attachment.d.ts

@@ -39,3 +39,10 @@ export declare const attachment: v.StrictObjectSchema<{
         readonly url: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, undefined>, undefined>, undefined>;
 }, undefined>;
+/** A file named on a search hit: `position` is the one `attachments show` and `messages download` take. */
+export declare const hitFile: v.StrictObjectSchema<{
+    readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly kind: v.StringSchema<undefined>;
+    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly size: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+}, undefined>;

package/dist/entities/attachment.js

@@ -35,3 +35,5 @@ export const attachment = v.strictObject({
         url: v.optional(text),
     })))),
 });
+/** A file named on a search hit: `position` is the one `attachments show` and `messages download` take. */
+export const hitFile = v.strictObject({ position: count, kind: text, name: v.optional(text), size: v.optional(count) });

package/dist/entities/hit.d.ts

@@ -24,6 +24,13 @@ export declare const hit: v.StrictObjectSchema<{
     readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    /** A message's files; absent when it has none. */
+    readonly attachments: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly size: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    }, undefined>, undefined>, undefined>;
     /** Absent on a note hit: the owner wrote it. */
     readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;

package/dist/entities/hit.js

@@ -1,4 +1,5 @@
 import * as v from "valibot";
+import { hitFile } from "./attachment.js";
 import { count, reference, text, time, untrusted } from "./fields.js";
 /** One result of `search all`: a message, a mail, a note, a calendar event or a meeting passage, best first. */
 export const hit = v.strictObject({
@@ -25,6 +26,8 @@ export const hit = v.strictObject({
     scope: v.optional(v.picklist(["transcript", "chat", "summary"])),
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     id: v.optional(v.pipe(v.string(), v.minLength(1))),
+    /** A message's files; absent when it has none. */
+    attachments: v.optional(v.array(hitFile)),
     /** Absent on a note hit: the owner wrote it. */
     untrusted,
 });

package/dist/entities/index.d.ts

@@ -40,7 +40,7 @@ import { inviteLink } from "./invite-link.js";
 import { job } from "./job.js";
 import { joinRequest } from "./join-request.js";
 import { organization, project, reminder } from "./knowledge-lists.js";
-import { botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, callRecord, scheduledJob, stickerInventory } from "./list-results.js";
+import { botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, callRecord, scheduledJob, stickerInventory, topicIcon } from "./list-results.js";
 import { messageEvent, serveSummary, watchedMessage, watchItem } from "./listener.js";
 import { mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer } from "./media-archive.js";
 import { meeting } from "./meeting.js";
@@ -88,7 +88,7 @@ import { topic } from "./topic.js";
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export declare const ENTITIES: {
     readonly meeting_ingestion: v.StrictObjectSchema<{
         readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -1231,6 +1231,13 @@ export declare const ENTITIES: {
                 readonly demoted: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
             }, undefined>, undefined>;
         }, undefined>, undefined>;
+        /** The files the message carries; absent when it has none. */
+        readonly attachments: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly size: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     }, undefined>;
     readonly "message.summary": Omit<v.StrictObjectSchema<{
@@ -1895,6 +1902,13 @@ export declare const ENTITIES: {
         readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly access: v.PicklistSchema<["public", "restricted", "unknown", "unavailable"], undefined>;
         readonly reason: v.NullableSchema<v.PicklistSchema<["unsupported_chat", "unsupported_provider", "offline"], undefined>, undefined>;
+        readonly files: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly reason: v.NullableSchema<v.PicklistSchema<["unsupported_provider"], undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
     }, undefined>;
     readonly message_write: v.StrictObjectSchema<{
         readonly operation_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -4441,6 +4455,9 @@ export declare const ENTITIES: {
         readonly name: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>;
+    readonly topic_icon: v.StrictObjectSchema<{
+        readonly emoji: v.StringSchema<undefined>;
+    }, undefined>;
     readonly bot_webhook: v.StrictObjectSchema<{
         readonly url: v.StringSchema<undefined>;
         readonly types: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
@@ -4551,6 +4568,12 @@ export declare const ENTITIES: {
         readonly offset_ms: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
         readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
         readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly attachments: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly size: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
     }, undefined>;
     readonly document: v.StrictObjectSchema<{
@@ -4763,6 +4786,12 @@ export declare const ENTITIES: {
         readonly project: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly project_key: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
         readonly project_name: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly created_by: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+            readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly owner: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly account: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
         readonly chat: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
         readonly source_message: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>, undefined>;
@@ -4833,6 +4862,12 @@ export declare const ENTITIES: {
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly project_key: v.StringSchema<undefined>;
         readonly project_name: v.StringSchema<undefined>;
+        readonly created_by: v.NullableSchema<v.StrictObjectSchema<{
+            readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly owner: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
         readonly title: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
@@ -4939,6 +4974,12 @@ export declare const ENTITIES: {
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly project_key: v.StringSchema<undefined>;
             readonly project_name: v.StringSchema<undefined>;
+            readonly created_by: v.NullableSchema<v.StrictObjectSchema<{
+                readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly owner: v.BooleanSchema<undefined>;
+            }, undefined>, undefined>;
             readonly title: v.StringSchema<undefined>;
             readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
@@ -5046,6 +5087,12 @@ export declare const ENTITIES: {
         readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly project_key: v.StringSchema<undefined>;
         readonly project_name: v.StringSchema<undefined>;
+        readonly created_by: v.NullableSchema<v.StrictObjectSchema<{
+            readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly owner: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
         readonly title: v.StringSchema<undefined>;
         readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
@@ -5181,6 +5228,12 @@ export declare const ENTITIES: {
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly project_key: v.StringSchema<undefined>;
             readonly project_name: v.StringSchema<undefined>;
+            readonly created_by: v.NullableSchema<v.StrictObjectSchema<{
+                readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly owner: v.BooleanSchema<undefined>;
+            }, undefined>, undefined>;
             readonly title: v.StringSchema<undefined>;
             readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;
@@ -5281,6 +5334,12 @@ export declare const ENTITIES: {
             readonly project: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly project_key: v.StringSchema<undefined>;
             readonly project_name: v.StringSchema<undefined>;
+            readonly created_by: v.NullableSchema<v.StrictObjectSchema<{
+                readonly type: v.PicklistSchema<["person", "bot"], undefined>;
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly owner: v.BooleanSchema<undefined>;
+            }, undefined>, undefined>;
             readonly title: v.StringSchema<undefined>;
             readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly type: v.PicklistSchema<readonly ["bug", "feature", "chore", "question", "request", "mention", "promise"], undefined>;