@wirecat/cli-core 0.399.0 → 0.401.0

package/dist/entities/task-results.js

@@ -0,0 +1,142 @@
+import * as v from "valibot";
+import { TASK_TYPES } from "../domain/knowledge.js";
+import { TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS } from "../tasks/index.js";
+import { count, id, reference, text, time } from "./fields.js";
+import { closeSuggestion } from "./task.js";
+import { taskPair } from "./task-pair.js";
+const nullableTime = v.nullable(time);
+const link = v.strictObject({
+    id,
+    from: reference,
+    to: v.nullable(reference),
+    kind: v.picklist([
+        "links-to",
+        "blocked-by",
+        "follow-up-of",
+        "about",
+        "member-of",
+        "labelled",
+        "answered-by",
+        "evidence",
+        "created-from",
+        "duplicate-of",
+        "related-to",
+        "assigned-to",
+    ]),
+    anchor: v.nullable(text),
+    origin: v.picklist(["file", "owner", "suggested", "message"]),
+    target_text: v.nullable(text),
+    role: v.nullable(text),
+    evidence: v.nullable(text),
+    provenance: v.nullable(text),
+    confirmed: v.boolean(),
+    created_at: time,
+});
+export const taskCard = v.strictObject({
+    id,
+    ref: reference,
+    key: text,
+    project: reference,
+    title: text,
+    description: v.nullable(text),
+    type: v.picklist(TASK_TYPES),
+    status: v.picklist(TASK_STATES),
+    priority: v.nullable(v.number()),
+    parent: v.nullable(reference),
+    source: v.nullable(text),
+    due_at: nullableTime,
+    next_check_at: nullableTime,
+    closed_at: nullableTime,
+    reason: v.nullable(text),
+    verdict: v.nullable(v.picklist(TASK_VERDICTS)),
+    category: v.nullable(text),
+    claimed_by: v.nullable(text),
+    claimed_until: nullableTime,
+    close_certainty: v.nullable(v.number()),
+    close_suggestion: v.nullable(closeSuggestion),
+    assignments: v.array(v.strictObject({ to: reference, role: v.picklist(["assignee", "reviewer", "watcher"]) })),
+    created_at: time,
+    updated_at: time,
+    links: v.array(link),
+    linked_from: v.array(link),
+});
+/** Service task receipts preserve source pointers and their on-demand previews. */
+const taskView = v.strictObject({
+    id,
+    source: text,
+    source_kind: text,
+    account: text,
+    group: text,
+    kind: v.picklist(TASK_KINDS),
+    state: v.picklist(TASK_STATES),
+    reason: v.optional(text),
+    origin: v.picklist(TASK_ORIGINS),
+    created_at: time,
+    due_at: v.optional(time),
+    closed_at: v.optional(time),
+    closed_by: v.optional(v.picklist(TASK_ORIGINS)),
+    key: v.optional(text),
+    category: v.optional(text),
+    claimed_by: v.optional(text),
+    claimed_until: v.optional(time),
+    message: v.nullable(v.strictObject({ sender_name: v.nullable(text), text, timestamp: time })),
+    note: v.optional(v.nullable(v.strictObject({ id, title: v.nullable(text), text, updated_at: time }))),
+});
+export const taskCreated = v.strictObject({
+    ...taskView.entries,
+    created: v.boolean(),
+    attached: v.optional(v.literal(true)),
+    review: v.optional(count),
+    follow_up_of: v.optional(taskPair.entries.other),
+    card: v.optional(taskCard),
+});
+export const taskClosed = v.strictObject({
+    ...taskView.entries,
+    close_certainty: v.nullable(v.number()),
+    close_suggestion: v.nullable(closeSuggestion),
+});
+export const taskLinks = v.union([
+    v.strictObject({ ...taskCard.entries, review: v.optional(count) }),
+    v.strictObject({
+        relations: v.array(v.strictObject({
+            id,
+            from: reference,
+            to: reference,
+            kind: v.picklist(["blocked-by", "follow-up-of", "related-to", "duplicate-of", "discovered-from"]),
+        })),
+    }),
+]);
+export const taskSimilar = v.strictObject({
+    ref: reference,
+    key: text,
+    title: text,
+    status: text,
+    created_at: time,
+    found_by: v.array(v.picklist(["text", "person", "category", "reply"])),
+    score: v.number(),
+    band: taskPair.entries.band,
+    levels: taskPair.entries.levels,
+    reasons: v.array(text),
+    text: v.strictObject({ shared_stems: count, all_stems: count, stems: v.number(), trigrams: v.number() }),
+});
+export const taskMerge = v.strictObject({ pair: taskPair, linked: count, review: count, task: taskCard });
+export const taskUnmerge = v.strictObject({ pair: taskPair, task: taskCard });
+export const taskCategories = v.strictObject({
+    categories: v.array(v.strictObject({
+        name: text,
+        meaning: text,
+        triggers: v.strictObject({ en: v.array(text), ru: v.array(text), es: v.array(text) }),
+    })),
+    unlisted: v.array(v.strictObject({ name: text, open: count, total: count })),
+    file: v.nullable(text),
+});
+export const taskScan = v.strictObject({
+    chat: text,
+    messages: count,
+    added: count,
+    closed: count,
+    review: count,
+    held: v.optional(count),
+    held_chats: v.optional(count),
+    tasks: v.array(v.strictObject({ source: text, kind: v.picklist(TASK_KINDS), category: v.nullable(text) })),
+});

package/dist/errors/reasons.js

@@ -8,6 +8,7 @@ const QUERY = [
     ["query.invalid-context", "the context size is out of range"],
     ["query.invalid-limit", "the limit is out of range"],
     ["query.invalid-scope", "the query selects no account"],
+    ["query.invalid-duration", "a duration in the query cannot be read"],
     ["query.invalid-size", "a size in the query cannot be read"],
     ["query.invalid-reference", "a reference in the query is not valid"],
     ["query.invalid-tag", "a tag in the query is not valid"],
@@ -25,10 +26,12 @@ const OTHERS = [
     ["extraction.invalid-proposals", "invalid_response", "the model's memory proposals could not be used"],
     validation("extraction.text-too-long", "the text is too long for memory extraction"),
     validation("file.locked", "another process holds the file's lock"),
+    ["mirror.partial", "provider_error", "some mirrored files were not synced"],
     ["profile.wrong-account", "authentication_error", "the signed-in source account does not match this profile"],
     validation("push.too-many-files", "the folder holds more files than one push takes"),
     validation("push.unreadable", "the folder to push could not be read"),
     validation("spreadsheet.unreadable", "the workbook could not be read"),
+    ["state.invalid", "configuration_error", "the saved sync state is unreadable or invalid; it is kept, not reset"],
     validation("store.refused", "the local store refused the document text"),
     ["store.not-writable", "permission_error", "the message store cannot be written from this process"],
     validation("catalog.scope-limit", "the selected catalog exceeds its entry limit"),

package/dist/mcp/agent.d.ts

@@ -53,6 +53,8 @@ export interface CatalogueOptions {
     /** Under `<PREFIX>_READ_ONLY`: a change on the messenger is not offered either. */
     readOnly?: boolean;
     keyOf?: (path: readonly string[]) => PermissionKey | null | undefined;
+    /** Whether a command changes what a later run may do (`grantsAuthority`): offered only under `mcp.authority`. */
+    authority?: (path: readonly string[]) => boolean;
     /** Arguments left out of every tool, by name. */
     omit?: readonly string[];
     /** Offer `offline` on commands that read the messenger: answer from the copy on this machine. */
@@ -64,7 +66,7 @@ export interface CatalogueOptions {
  * One tool per command an agent may run under `root` (NEED-1411): every leaf command and every group that runs on
  * its own, except one marked
  * `mcp: false` (on itself or a group above it), one with a `lifetime` — an agent call must return — and one the
- * profile's levels refuse. Its input is the command's arguments and options in snake_case, typed as far as the
+ * profile's levels refuse, which include `mcp.authority` for what `authority` names. Its input is the command's arguments and options in snake_case, typed as far as the
  * command tree and the shared flag vocabulary say; an option marked `mcp: false` is left out.
  */
 export declare const toolsFromCommands: (commands: readonly CommandInfo[], options?: CatalogueOptions) => AgentTool[];

package/dist/mcp/agent.js

@@ -6,7 +6,7 @@ import { VOCABULARY } from "@wirecat/cli-base/standards/tables";
 import * as v from "valibot";
 import { changesMessenger } from "../cli/effects.js";
 import { lentConnection } from "../cli/messenger/serve-relay.js";
-import { keyForCommand, levelFor, readKeysForCommand } from "../sends/permissions.js";
+import { AUTHORITY_KEY, authorityAllowed, keyForCommand, levelFor, readKeysForCommand, } from "../sends/permissions.js";
 const TYPES = new Map(VOCABULARY.flags.map((flag) => [flag.name, flag.type]));
 // `<name|id>` is one argument: its field is `name_or_id`.
 const snake = (name) => name.replaceAll("|", "_or_").replace(/[^a-z0-9]+/gi, "_");
@@ -24,6 +24,8 @@ const optionKind = (option, long) => {
         return type;
     if (/<json>/.test(option.flags))
         return "json";
+    if (Array.isArray(option.default))
+        return "repeat";
     return /\.\.\.[>\]]/.test(option.flags) ? "variadic" : "text";
 };
 const optionField = (option, long, negatable = false) => {
@@ -38,8 +40,8 @@ const optionField = (option, long, negatable = false) => {
                     v.pipe(v.number(), v.integer(), v.minValue(0), v.description(about))
                 : kind === "number"
                     ? v.pipe(v.number(), v.description(about))
-                    : kind === "list"
-                        ? // The command line takes `a,b`; an agent may write it so, or as a list.
+                    : kind === "list" || kind === "repeat"
+                        ? // The command line takes `a,b` or the flag repeated; an agent may write one value, or a list.
                             v.pipe(v.union([v.pipe(v.array(text("one value")), v.minLength(1)), text(about)]), v.description(about))
                         : kind === "variadic"
                             ? v.pipe(v.array(text("one value")), v.minLength(1), v.description(about))
@@ -58,6 +60,8 @@ const optionField = (option, long, negatable = false) => {
                 return value === true ? [long] : negatable ? [`--no-${long.slice(2)}`] : [];
             if (kind === "variadic")
                 return value.map((one) => `${long}=${String(one)}`);
+            if (kind === "repeat")
+                return (Array.isArray(value) ? value : [value]).map((one) => `${long}=${String(one)}`);
             if (kind === "list")
                 return [`${long}=${Array.isArray(value) ? value.map(String).join(",") : String(value)}`];
             if (kind === "json")
@@ -115,7 +119,9 @@ const fieldsOf = (info, { omit = [], offline = false, stdin }) => {
 const schemaOf = (fields) => v.object(Object.fromEntries(fields.map((field) => [field.name, field.required ? field.schema : v.optional(field.schema)])));
 const startsWith = (path, prefix) => prefix.every((word, at) => path[at] === word);
 /** Why the profile refuses this command now, or nothing. */
-const refusal = (info, levels, keyOf) => {
+const refusal = (info, levels, keyOf, authority) => {
+    if (authority?.(info.path) && !authorityAllowed(levels))
+        return `the profile keeps ${AUTHORITY_KEY} off`;
     const key = keyOf?.(info.path) ?? keyForCommand(info.path);
     const level = key ? levelFor(levels, key).level : "allow";
     if (level === "deny")
@@ -129,22 +135,22 @@ const refusal = (info, levels, keyOf) => {
  * One tool per command an agent may run under `root` (NEED-1411): every leaf command and every group that runs on
  * its own, except one marked
  * `mcp: false` (on itself or a group above it), one with a `lifetime` — an agent call must return — and one the
- * profile's levels refuse. Its input is the command's arguments and options in snake_case, typed as far as the
+ * profile's levels refuse, which include `mcp.authority` for what `authority` names. Its input is the command's arguments and options in snake_case, typed as far as the
  * command tree and the shared flag vocabulary say; an option marked `mcp: false` is left out.
  */
 export const toolsFromCommands = (commands, options = {}) => {
-    const { root = [], exclude = [], levels, keyOf, readOnly = false } = options;
+    const { root = [], exclude = [], levels, keyOf, authority, readOnly = false } = options;
     return flatten(commands)
         .filter((info) => 
-    // A group that also runs on its own declares effects: `tasks duplicates` lists, its subcommands decide.
+    // Only a group that declares effects can run without a leaf.
     (info.commands.length === 0 || info.effects !== undefined) &&
         info.path.length > root.length &&
         startsWith(info.path, root) &&
         !exclude.some((skipped) => startsWith(info.path.slice(root.length), skipped)) &&
         info.mcp !== false &&
         info.lifetime === undefined &&
-        !(readOnly && changesMessenger(info)) &&
-        (levels === undefined || refusal(info, levels, keyOf) === undefined))
+        !(readOnly && (changesMessenger(info) || authority?.(info.path))) &&
+        (levels === undefined || refusal(info, levels, keyOf, authority) === undefined))
         .map((info) => ({
         command: info.path.slice(root.length).join(" "),
         path: info.path,
@@ -191,7 +197,7 @@ const argvOf = (info, input, profile, stdin) => {
 export const runCommandForAgent = async (program, path, input, ctx) => {
     try {
         const info = flatten(program.commands).find((one) => one.path.length === path.length && startsWith(one.path, path));
-        // A group runs when it declares effects of its own, as `toolsFromCommands` offers it: `tasks duplicates` lists.
+        // Runnable groups declare effects, as `toolsFromCommands` offers them.
         if (!info || (info.commands.length > 0 && info.effects === undefined))
             throw new CliError("validation_error", `no command "${path.join(" ")}" to run`);
         if (info.lifetime)
@@ -223,6 +229,7 @@ export const runCommandForAgent = async (program, path, input, ctx) => {
                     failure = object;
                 },
                 ...(ctx.overrides?.length ? { overrides: ctx.overrides } : {}),
+                authority: levels !== undefined && authorityAllowed(levels),
             },
             // Opened only when the command asks: a read the store answers never connects.
             ...(lend

package/dist/mcp/bot/server.d.ts

@@ -14,6 +14,8 @@ export interface BotServerOptions {
     levels?: () => Readonly<Record<PermissionKey, Level>>;
     /** The key a CLI's own bot command is guarded by, from its full path, when `keyForCommand` does not know it. */
     keyOf?: (path: readonly string[]) => PermissionKey | null | undefined;
+    /** Whether a command changes what a later run may do; such a command is offered only under `mcp.authority`. */
+    authority?: (path: readonly string[]) => boolean;
     env: NodeJS.ProcessEnv;
     skill?: URL;
 }

package/dist/mcp/bot/server.js

@@ -28,6 +28,7 @@ export const createBotServer = (options) => {
         levels: settings.permissions,
         readOnly: readOnlyLockOf(bot.app, env) !== undefined,
         ...(options.keyOf ? { keyOf: options.keyOf } : {}),
+        ...(options.authority ? { authority: options.authority } : {}),
         offline: true,
         // Another bot's copy is this bot's to read only where `read_other_bots` says so.
         ...(settings.readOtherBots ? {} : { omit: ["all_bots", "bots"] }),

package/dist/mcp/server.js

@@ -8,7 +8,7 @@ import * as v from "valibot";
 import { findCommand } from "../cli/command-contract.js";
 import { environmentOf } from "../cli/context.js";
 import { refuseWriteBeforeConnecting } from "../cli/early-refusal.js";
-import { judgedTargets } from "../cli/effects.js";
+import { changesAuthorityAt, judgedTargets } from "../cli/effects.js";
 import { itemOf } from "../cli/envelope.js";
 import { DEFAULT_OUTPUT_BYTES } from "../cli/execution.js";
 import { recalledAccount } from "../cli/messenger/accounts.js";
@@ -98,6 +98,7 @@ export const createServer = (command, context, messenger, sessionOptions) => {
             return undefined;
         }
     };
+    const authority = changesAuthorityAt(root);
     const stdin = (path) => {
         try {
             return stdinFieldOf(findCommand(root, path));
@@ -115,6 +116,7 @@ export const createServer = (command, context, messenger, sessionOptions) => {
         levels: settings.permissions,
         readOnly: readOnlyLockOf(app, context.env) !== undefined,
         keyOf,
+        authority,
         offline: true,
         stdin,
     }).map((one) => "sync_first" in one.input.entries && !syncAllowed(one.path)

package/dist/mcp/tools/attachments.js

@@ -9,6 +9,7 @@ export const attachmentsTools = (messenger) => {
     const _command = messenger.app.command;
     return {
         attachments_show: tool({
+            output: { entity: "attachment_bytes", list: false },
             title: "Read bytes of one retained attachment",
             outputLimit: (args, defaults) => args.page === undefined
                 ? DEFAULT_OUTPUT_BYTES

package/dist/meetings/cli/index.js

@@ -5,6 +5,7 @@ import { exportMeeting } from "../export.js";
 import { importFiles } from "../import.js";
 import { MEETING_QUERY } from "../item.js";
 import { pull } from "../pull.js";
+import { eventItem } from "../read-answers.js";
 import { listed, MEETING_QUERY_GUIDE, MeetingError, meetingDetailsAnswer, meetingPeople, meetingSummaryAnswer, meetingsList, meetingsQuery, meetingTranscriptAnswer, } from "../reads.js";
 import { SAVE_HELP } from "../save-hints.js";
 import { queryWordsAfterOptions } from "./query-options.js";
@@ -94,7 +95,7 @@ export const addMeetingCommands = (program, deps) => {
         else
             print(result, command);
     });
-    output(annotate(group.command("people"), { effects: LOCAL_READ })
+    output(annotate(group.command("people"), { effects: LOCAL_READ, output: { entity: "meeting_participants" } })
         .description("find meeting participants by name or email")
         .argument("<query>", "a name or an email address"))
         .option("--limit <n>", "most matching observations per page, 1–1000 (default 50)", integer)
@@ -137,8 +138,9 @@ export const addMeetingCommands = (program, deps) => {
     });
     output(annotate(program.command("events").description("the owner's stored events").command("list"), {
         effects: LOCAL_READ,
+        output: { entity: "event" },
     }).description("list stored events")).action(async (_opts, command) => {
-        print(listed(await deps.store.events()), command);
+        print(listed((await deps.store.events()).map(eventItem)), command);
     });
 };
 export { addMeetingPassageCommand, createMeetingPassageCommand, meetingPassageRequest, } from "./passage.js";

package/dist/meetings/cli/passage.js

@@ -39,6 +39,7 @@ export const createMeetingPassageCommand = (program) => {
         .default("text")), {
         origin: "handwritten",
         effects: { remote: "none", local: "read" },
+        output: { entity: "meeting_passage" },
         examples: [`${program.name()} meetings passage meeting:1/1/1/0 --json`],
     });
 };

package/dist/meetings/index.d.ts

@@ -9,7 +9,7 @@ export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRu
 export { liftMeetingFields, MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
-export { CHAT_MESSAGES_READ, type MeetingChatLine, type MeetingChatLinesInput, type MeetingChatLinesStore, } from "./links.js";
+export { CHAT_MESSAGES_READ, type MeetingChatLine, type MeetingChatLinesInput, type MeetingChatLinesStore, type MeetingLink, } from "./links.js";
 export { createMeetingContext, MEETING_FACT_TYPES, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, type ManagedMeeting, type ManagedMeetingChange, type MeetingManagement, type MeetingManagementPorts, type MeetingMutationOptions, type MeetingMutationProposal, type MeetingMutationReceipt, type MeetingOperationOptions, type MeetingProviderContext, validateMeetingChange, } from "./meeting-management.js";
 export type { Attachment, ChatLine, Event, EventSeries, JsonValue, Meeting, MeetingSeries, Metadata, Occurrence, Participant, RecordTimes, SourceChatLine, SourceMeeting, Summary, SummaryContent, Transcript, TranscriptLine, TranscriptRow, } from "./model.js";
@@ -25,6 +25,7 @@ export { type MeetingProjectEvidenceAnswer, type MeetingProjectEvidenceItem, mee
 export { MEETING_PROJECT_EVIDENCE_QUERY, type MeetingProjectEvidenceRequest, prepareMeetingProjectEvidence, } from "./project-evidence-query.js";
 export { type MeetingProviderScope, snapshotMeetingScope } from "./provider.js";
 export { type PullOptions, pull, type RunReport } from "./pull.js";
+export { event, eventItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
 export type { MeetingContextReadCapabilities, MeetingReadBudget, MeetingReadCapabilities, MeetingReadScope, TranscriptContextInput, TranscriptContextPage, TranscriptPage, TranscriptReadScope, TranscriptRowPage, } from "./read-store.js";
 export { listed, MeetingError, meetingDetailsAnswer, meetingPeople, meetingSummaryAnswer, meetingTranscriptAnswer, type TranscriptReadOptions, } from "./reads.js";
 export { installRecordingArchiveSchedule, parseRecordingArchiveSchedule, planRecordingArchiveSchedule, type RecordingArchiveSchedule, type RecordingArchiveScheduleInput, type RecordingArchiveScheduler, recordingArchiveScheduleWindow, } from "./recording-schedule.js";

package/dist/meetings/index.js

@@ -18,6 +18,7 @@ export { meetingProjectEvidence, meetingProjectEvidenceAnswer, } from "./project
 export { MEETING_PROJECT_EVIDENCE_QUERY, prepareMeetingProjectEvidence, } from "./project-evidence-query.js";
 export { snapshotMeetingScope } from "./provider.js";
 export { pull } from "./pull.js";
+export { event, eventItem, meetingLink, meetingLinkItem, meetingParticipants, meetingPassage, meetingReview, meetingReviewItem, meetingSpeaker, meetingSpeakerItem, meetingStats, meetingStatsItem, } from "./read-answers.js";
 export { listed, MeetingError, meetingDetailsAnswer, meetingPeople, meetingSummaryAnswer, meetingTranscriptAnswer, } from "./reads.js";
 export { installRecordingArchiveSchedule, parseRecordingArchiveSchedule, planRecordingArchiveSchedule, recordingArchiveScheduleWindow, } from "./recording-schedule.js";
 export { parseRecordingSyncCheckpoint, RecordingSyncError, recordingAssetFingerprint, recordingWindows, syncRecordingArchive, } from "./recording-sync.js";

package/dist/meetings/links.d.ts

@@ -15,4 +15,20 @@ export interface MeetingChatLine {
 export interface MeetingChatLinesStore {
     meetingChatLines(input: MeetingChatLinesInput): Promise<MeetingChatLine[]>;
 }
+/** One link as the meetings' chat holds it: where and how often it was shared. */
+export interface MeetingLink {
+    url: string;
+    domain: string | null;
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    documentId: string | null;
+    count: number;
+    firstAt: number;
+    lastAt: number;
+    senders: string[];
+    meetings: {
+        meetingId: number;
+        accountId: number;
+        title: string | null;
+    }[];
+}
 export declare const CHAT_MESSAGES_READ = 100000;

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

@@ -0,0 +1,185 @@
+import * as v from "valibot";
+import type { MeetingLink } from "./links.js";
+import type { Event } from "./model.js";
+import type { MeetingReviewItem } from "./review.js";
+import type { MeetingSpeakerStats, MeetingStats } from "./stats.js";
+/** One meeting in `review`: what the store holds about it, never transcript text. */
+export declare const meetingReview: v.StrictObjectSchema<{
+    readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly started_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly duration_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly participants_count: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    readonly projects: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    /** Null when the meeting has no current transcript. */
+    readonly transcript: v.NullableSchema<v.StrictObjectSchema<{
+        readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    /** The three who talked longest. */
+    readonly speakers: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    /** The newest stored summary; null when there is none. */
+    readonly summary: v.NullableSchema<v.StrictObjectSchema<{
+        readonly source: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly overview: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly next_steps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly url: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingReviewItem: (one: MeetingReviewItem) => v.InferOutput<typeof meetingReview>;
+/** A link shared in meeting chat, with where and how often; `mentions list` answers these. */
+export declare const meetingLink: v.StrictObjectSchema<{
+    readonly url: v.StringSchema<undefined>;
+    readonly domain: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The Google Docs, Sheets, Slides, Forms or Drive file it names. */
+    readonly document_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly first_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 last_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 senders: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly meetings: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingLinkItem: (link: MeetingLink) => v.InferOutput<typeof meetingLink>;
+/** One speaker's talk over the selected meetings; `stats meetings top` answers these. */
+export declare const meetingSpeaker: v.StrictObjectSchema<{
+    /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+    readonly key: v.StringSchema<undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly person_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly identity_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** This speaker's part of all talk time, 0–1. */
+    readonly share: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+}, undefined>;
+export declare const meetingSpeakerItem: (one: MeetingSpeakerStats) => v.InferOutput<typeof meetingSpeaker>;
+/** `stats meetings show`: how much was said over the selected meetings, by week, with the top speakers. */
+export declare const meetingStats: v.StrictObjectSchema<{
+    readonly time_zone: v.StringSchema<undefined>;
+    readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    /** `week_start` is the Monday, as a date in `time_zone`. */
+    readonly weeks: v.ArraySchema<v.StrictObjectSchema<{
+        readonly week_start: v.StringSchema<undefined>;
+        readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>, undefined>;
+    readonly top_speakers: v.ArraySchema<v.StrictObjectSchema<{
+        /** `person:<id>`, `identity:<id>`, `name:<lowercased name>` or `unknown`. */
+        readonly key: v.StringSchema<undefined>;
+        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly person_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly identity_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly lines: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly words: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly talk_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        /** This speaker's part of all talk time, 0–1. */
+        readonly share: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>;
+    }, undefined>, undefined>;
+}, undefined>;
+export declare const meetingStatsItem: (found: MeetingStats, top?: number) => v.InferOutput<typeof meetingStats>;
+/** `meetings people`: one page of participant observations whose name or email matches. */
+export declare const meetingParticipants: v.StrictObjectSchema<{
+    readonly schema_version: v.LiteralSchema<1, undefined>;
+    readonly kind: v.LiteralSchema<"meeting_participants", undefined>;
+    readonly account_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    readonly query: v.StringSchema<undefined>;
+    readonly items: v.ArraySchema<v.StrictObjectSchema<{
+        readonly participant_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly identity_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly display_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** Several identities on one page are observations, never speaker attribution or person links. */
+    readonly ambiguity: v.StrictObjectSchema<{
+        readonly scope: v.LiteralSchema<"page", undefined>;
+        readonly multiple_identities: v.BooleanSchema<undefined>;
+        readonly identity_ids: v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    }, undefined>;
+    readonly coverage: v.StrictObjectSchema<{
+        readonly scanned: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly read_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly archive_completeness: v.LiteralSchema<"unknown", undefined>;
+        readonly truncated_by: v.NullableSchema<v.PicklistSchema<("limit" | "read_bytes" | "scan_limit")[], undefined>, undefined>;
+    }, undefined>;
+    readonly page: v.StrictObjectSchema<{
+        readonly mode: v.LiteralSchema<"cursor", undefined>;
+        readonly limit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly next_cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+/** `meetings passage`: a transcript line with the lines around it. */
+export declare const meetingPassage: v.StrictObjectSchema<{
+    readonly schema_version: v.LiteralSchema<1, undefined>;
+    readonly kind: v.LiteralSchema<"meeting_context", undefined>;
+    readonly source: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly target_ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+    readonly target_fingerprint: v.StringSchema<undefined>;
+    readonly fingerprint: v.StringSchema<undefined>;
+    readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+    readonly limits: v.StrictObjectSchema<{
+        readonly before: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly after: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly max_read_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    }, undefined>;
+    readonly content_bytes: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly coverage: v.StrictObjectSchema<{
+        readonly included: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly before: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly after: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_before: v.BooleanSchema<undefined>;
+        readonly has_after: v.BooleanSchema<undefined>;
+        readonly truncated_by: v.NullableSchema<v.PicklistSchema<"bytes"[], undefined>, undefined>;
+        readonly before_ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly after_ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly continuation: v.LiteralSchema<"anchor-inclusive", undefined>;
+        readonly archive_completeness: v.LiteralSchema<"unknown", undefined>;
+        readonly input: v.LiteralSchema<"bounded-meeting-context", undefined>;
+    }, undefined>;
+    readonly items: v.ArraySchema<v.StrictObjectSchema<{
+        readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+        readonly fingerprint: v.StringSchema<undefined>;
+        readonly transcript_id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+        readonly content_hash: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly start_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly end_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly speaker_participant_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+        readonly speaker_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly text: v.StringSchema<undefined>;
+        readonly revision: v.PicklistSchema<["current", "superseded"], undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/** A stored event a meeting belongs to; `id` is what `meetings update --event-id` takes. */
+export declare const event: v.StrictObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly event_series_id: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly location: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly starts_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly ends_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly timezone: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** `auto`: made from a meeting; `owner`: made by hand. */
+    readonly origin: v.PicklistSchema<["auto", "owner"], undefined>;
+    readonly deleted_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+    readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+    readonly updated_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+}, undefined>;
+export declare const eventItem: (one: Event) => v.InferOutput<typeof event>;